w32tex
About: TeX Live provides a comprehensive TeX system including all the major TeX-related programs, macro packages, and fonts that are free software. Windows sources.
  Fossies Dox: w32tex-src.tar.xz  ("unofficial" and yet experimental doxygen-generated source code documentation)  

pl-parser.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.0.4. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015 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 "3.0.4"
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 
62 
63 
64 /* Copy the first part of user declarations. */
65 #line 1 "pl-parser.y" /* yacc.c:339 */
66 
67 /* pl-parser.y: Grammar for reading property list files
68 
69 This file is part of Omega,
70 which is based on the web2c distribution of TeX,
71 
72 Copyright (c) 1994--2001 John Plaice and Yannis Haralambous
73 
74 Omega is free software; you can redistribute it and/or modify
75 it under the terms of the GNU General Public License as published by
76 the Free Software Foundation; either version 2 of the License, or
77 (at your option) any later version.
78 
79 Omega is distributed in the hope that it will be useful,
80 but WITHOUT ANY WARRANTY; without even the implied warranty of
81 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
82 GNU General Public License for more details.
83 
84 You should have received a copy of the GNU General Public License
85 along with Omega; if not, write to the Free Software Foundation, Inc.,
86 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
87 
88 */
89 
90 #include "cpascal.h"
91 #include "parser.h"
92 #include "pl-parser.h"
93 #include "manifests.h"
94 #include "list_routines.h"
95 #include "error_routines.h"
96 #include "out_routines.h"
97 #include "char_routines.h"
98 #include "header_routines.h"
99 #include "param_routines.h"
100 #include "dimen_routines.h"
101 #include "ligkern_routines.h"
102 #include "print_routines.h"
103 #include "font_routines.h"
104 #include "extra_routines.h"
105 
106 
107 #line 108 "pl-parser.c" /* yacc.c:339 */
108 
109 # ifndef YY_NULLPTR
110 # if defined __cplusplus && 201103L <= __cplusplus
111 # define YY_NULLPTR nullptr
112 # else
113 # define YY_NULLPTR 0
114 # endif
115 # endif
116 
117 /* Enabling verbose error messages. */
118 #ifdef YYERROR_VERBOSE
119 # undef YYERROR_VERBOSE
120 # define YYERROR_VERBOSE 1
121 #else
122 # define YYERROR_VERBOSE 0
123 #endif
124 
125 /* In a future release of Bison, this section will be replaced
126  by #include "y.tab.h". */
127 #ifndef YY_YY__TEX_LIVE_TEXK_WEB_C_OMEGAFONTS_PL_PARSER_H_INCLUDED
128 # define YY_YY__TEX_LIVE_TEXK_WEB_C_OMEGAFONTS_PL_PARSER_H_INCLUDED
129 /* Debug traces. */
130 #ifndef YYDEBUG
131 # define YYDEBUG 0
132 #endif
133 #if YYDEBUG
134 extern int yydebug;
135 #endif
136 
137 /* Token type. */
138 #ifndef YYTOKENTYPE
139 # define YYTOKENTYPE
140  enum yytokentype
141  {
142  LEFT = 258,
143  RIGHT = 259,
144  NUMBER = 260,
145  FIX = 261,
146  COMMENT = 262,
147  CHECKSUM = 263,
148  DESIGNSIZE = 264,
149  DESIGNUNITS = 265,
150  CODINGSCHEME = 266,
151  FAMILY = 267,
152  FACE = 268,
153  SEVENBITSAFEFLAG = 269,
154  HEADER = 270,
155  FONTDIMEN = 271,
156  LIGTABLE = 272,
157  BOUNDARYCHAR = 273,
158  CHARACTER = 274,
159  NAMEDPARAMETER = 275,
160  PARAMETER = 276,
161  CHARMEASURE = 277,
162  NEXTLARGER = 278,
163  VARCHAR = 279,
164  EXTEN = 280,
165  LABEL = 281,
166  LIG = 282,
167  KRN = 283,
168  STOP = 284,
169  SKIP = 285,
170  VTITLE = 286,
171  MAPFONT = 287,
172  FONTNAME = 288,
173  FONTAREA = 289,
174  FONTCHECKSUM = 290,
175  FONTAT = 291,
176  FONTDSIZE = 292,
177  MAP = 293,
178  SELECTFONT = 294,
179  SETCHAR = 295,
180  SETRULE = 296,
181  MOVE = 297,
182  PUSH = 298,
183  POP = 299,
184  SPECIAL = 300,
185  SPECIALHEX = 301,
186  CHARREPEAT = 302,
187  FONTIVALUE = 303,
188  FONTFVALUE = 304,
189  FONTMVALUE = 305,
190  FONTPENALTY = 306,
191  FONTRULE = 307,
192  FONTGLUE = 308,
193  CLABEL = 309,
194  CKRN = 310,
195  CGLUE = 311,
196  CPENALTY = 312,
197  CPENGLUE = 313,
198  CHARIVALUE = 314,
199  CHARFVALUE = 315,
200  CHARMVALUE = 316,
201  CHARPENALTY = 317,
202  CHARRULE = 318,
203  CHARGLUE = 319,
204  IVALUE = 320,
205  IVALUEVAL = 321,
206  MVALUE = 322,
207  MVALUEVAL = 323,
208  FVALUE = 324,
209  FVALUEVAL = 325,
210  PENALTY = 326,
211  PENALTYVAL = 327,
212  RULE = 328,
213  RULEMEASURE = 329,
214  GLUE = 330,
215  GLUEWD = 331,
216  GLUETYPE = 332,
217  GLUEKIND = 333,
218  GLUERULE = 334,
219  GLUECHAR = 335,
220  GLUESHRINKSTRETCH = 336,
221  GLUEORDER = 337,
222  OFMLEVEL = 338,
223  FONTDIR = 339,
224  ACCENT = 340
225  };
226 #endif
227 /* Tokens. */
228 #define LEFT 258
229 #define RIGHT 259
230 #define NUMBER 260
231 #define FIX 261
232 #define COMMENT 262
233 #define CHECKSUM 263
234 #define DESIGNSIZE 264
235 #define DESIGNUNITS 265
236 #define CODINGSCHEME 266
237 #define FAMILY 267
238 #define FACE 268
239 #define SEVENBITSAFEFLAG 269
240 #define HEADER 270
241 #define FONTDIMEN 271
242 #define LIGTABLE 272
243 #define BOUNDARYCHAR 273
244 #define CHARACTER 274
245 #define NAMEDPARAMETER 275
246 #define PARAMETER 276
247 #define CHARMEASURE 277
248 #define NEXTLARGER 278
249 #define VARCHAR 279
250 #define EXTEN 280
251 #define LABEL 281
252 #define LIG 282
253 #define KRN 283
254 #define STOP 284
255 #define SKIP 285
256 #define VTITLE 286
257 #define MAPFONT 287
258 #define FONTNAME 288
259 #define FONTAREA 289
260 #define FONTCHECKSUM 290
261 #define FONTAT 291
262 #define FONTDSIZE 292
263 #define MAP 293
264 #define SELECTFONT 294
265 #define SETCHAR 295
266 #define SETRULE 296
267 #define MOVE 297
268 #define PUSH 298
269 #define POP 299
270 #define SPECIAL 300
271 #define SPECIALHEX 301
272 #define CHARREPEAT 302
273 #define FONTIVALUE 303
274 #define FONTFVALUE 304
275 #define FONTMVALUE 305
276 #define FONTPENALTY 306
277 #define FONTRULE 307
278 #define FONTGLUE 308
279 #define CLABEL 309
280 #define CKRN 310
281 #define CGLUE 311
282 #define CPENALTY 312
283 #define CPENGLUE 313
284 #define CHARIVALUE 314
285 #define CHARFVALUE 315
286 #define CHARMVALUE 316
287 #define CHARPENALTY 317
288 #define CHARRULE 318
289 #define CHARGLUE 319
290 #define IVALUE 320
291 #define IVALUEVAL 321
292 #define MVALUE 322
293 #define MVALUEVAL 323
294 #define FVALUE 324
295 #define FVALUEVAL 325
296 #define PENALTY 326
297 #define PENALTYVAL 327
298 #define RULE 328
299 #define RULEMEASURE 329
300 #define GLUE 330
301 #define GLUEWD 331
302 #define GLUETYPE 332
303 #define GLUEKIND 333
304 #define GLUERULE 334
305 #define GLUECHAR 335
306 #define GLUESHRINKSTRETCH 336
307 #define GLUEORDER 337
308 #define OFMLEVEL 338
309 #define FONTDIR 339
310 #define ACCENT 340
311 
312 /* Value type. */
313 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
314 typedef int YYSTYPE;
315 # define YYSTYPE_IS_TRIVIAL 1
316 # define YYSTYPE_IS_DECLARED 1
317 #endif
318 
319 
320 extern YYSTYPE yylval;
321 
322 int yyparse (void);
323 
324 #endif /* !YY_YY__TEX_LIVE_TEXK_WEB_C_OMEGAFONTS_PL_PARSER_H_INCLUDED */
325 
326 /* Copy the second part of user declarations. */
327 
328 #line 329 "pl-parser.c" /* yacc.c:358 */
329 
330 #ifdef short
331 # undef short
332 #endif
333 
334 #ifdef YYTYPE_UINT8
335 typedef YYTYPE_UINT8 yytype_uint8;
336 #else
337 typedef unsigned char yytype_uint8;
338 #endif
339 
340 #ifdef YYTYPE_INT8
341 typedef YYTYPE_INT8 yytype_int8;
342 #else
343 typedef signed char yytype_int8;
344 #endif
345 
346 #ifdef YYTYPE_UINT16
347 typedef YYTYPE_UINT16 yytype_uint16;
348 #else
349 typedef unsigned short int yytype_uint16;
350 #endif
351 
352 #ifdef YYTYPE_INT16
353 typedef YYTYPE_INT16 yytype_int16;
354 #else
355 typedef short int yytype_int16;
356 #endif
357 
358 #ifndef YYSIZE_T
359 # ifdef __SIZE_TYPE__
360 # define YYSIZE_T __SIZE_TYPE__
361 # elif defined size_t
362 # define YYSIZE_T size_t
363 # elif ! defined YYSIZE_T
364 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
365 # define YYSIZE_T size_t
366 # else
367 # define YYSIZE_T unsigned int
368 # endif
369 #endif
370 
371 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
372 
373 #ifndef YY_
374 # if defined YYENABLE_NLS && YYENABLE_NLS
375 # if ENABLE_NLS
376 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
377 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
378 # endif
379 # endif
380 # ifndef YY_
381 # define YY_(Msgid) Msgid
382 # endif
383 #endif
384 
385 #ifndef YY_ATTRIBUTE
386 # if (defined __GNUC__ \
387  && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
388  || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
389 # define YY_ATTRIBUTE(Spec) __attribute__(Spec)
390 # else
391 # define YY_ATTRIBUTE(Spec) /* empty */
392 # endif
393 #endif
394 
395 #ifndef YY_ATTRIBUTE_PURE
396 # define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
397 #endif
398 
399 #ifndef YY_ATTRIBUTE_UNUSED
400 # define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
401 #endif
402 
403 #if !defined _Noreturn \
404  && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
405 # if defined _MSC_VER && 1200 <= _MSC_VER
406 # define _Noreturn __declspec (noreturn)
407 # else
408 # define _Noreturn YY_ATTRIBUTE ((__noreturn__))
409 # endif
410 #endif
411 
412 /* Suppress unused-variable warnings by "using" E. */
413 #if ! defined lint || defined __GNUC__
414 # define YYUSE(E) ((void) (E))
415 #else
416 # define YYUSE(E) /* empty */
417 #endif
418 
419 #if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
420 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
421 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
422  _Pragma ("GCC diagnostic push") \
423  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
424  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
425 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
426  _Pragma ("GCC diagnostic pop")
427 #else
428 # define YY_INITIAL_VALUE(Value) Value
429 #endif
430 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
431 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
432 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
433 #endif
434 #ifndef YY_INITIAL_VALUE
435 # define YY_INITIAL_VALUE(Value) /* Nothing. */
436 #endif
437 
438 
439 #if ! defined yyoverflow || YYERROR_VERBOSE
440 
441 /* The parser invokes alloca or malloc; define the necessary symbols. */
442 
443 # ifdef YYSTACK_USE_ALLOCA
444 # if YYSTACK_USE_ALLOCA
445 # ifdef __GNUC__
446 # define YYSTACK_ALLOC __builtin_alloca
447 # elif defined __BUILTIN_VA_ARG_INCR
448 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
449 # elif defined _AIX
450 # define YYSTACK_ALLOC __alloca
451 # elif defined _MSC_VER
452 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
453 # define alloca _alloca
454 # else
455 # define YYSTACK_ALLOC alloca
456 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
457 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
458  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
459 # ifndef EXIT_SUCCESS
460 # define EXIT_SUCCESS 0
461 # endif
462 # endif
463 # endif
464 # endif
465 # endif
466 
467 # ifdef YYSTACK_ALLOC
468  /* Pacify GCC's 'empty if-body' warning. */
469 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
470 # ifndef YYSTACK_ALLOC_MAXIMUM
471  /* The OS might guarantee only one guard page at the bottom of the stack,
472  and a page size can be as small as 4096 bytes. So we cannot safely
473  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
474  to allow for a few compiler-allocated temporary stack slots. */
475 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
476 # endif
477 # else
478 # define YYSTACK_ALLOC YYMALLOC
479 # define YYSTACK_FREE YYFREE
480 # ifndef YYSTACK_ALLOC_MAXIMUM
481 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
482 # endif
483 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
484  && ! ((defined YYMALLOC || defined malloc) \
485  && (defined YYFREE || defined free)))
486 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
487 # ifndef EXIT_SUCCESS
488 # define EXIT_SUCCESS 0
489 # endif
490 # endif
491 # ifndef YYMALLOC
492 # define YYMALLOC malloc
493 # if ! defined malloc && ! defined EXIT_SUCCESS
494 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
495 # endif
496 # endif
497 # ifndef YYFREE
498 # define YYFREE free
499 # if ! defined free && ! defined EXIT_SUCCESS
500 void free (void *); /* INFRINGES ON USER NAME SPACE */
501 # endif
502 # endif
503 # endif
504 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
505 
506 
507 #if (! defined yyoverflow \
508  && (! defined __cplusplus \
509  || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
510 
511 /* A type that is properly aligned for any stack member. */
512 union yyalloc
513 {
516 };
517 
518 /* The size of the maximum gap between one aligned stack and the next. */
519 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
520 
521 /* The size of an array large to enough to hold all stacks, each with
522  N elements. */
523 # define YYSTACK_BYTES(N) \
524  ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
525  + YYSTACK_GAP_MAXIMUM)
526 
527 # define YYCOPY_NEEDED 1
528 
529 /* Relocate STACK from its old location to the new one. The
530  local variables YYSIZE and YYSTACKSIZE give the old and new number of
531  elements in the stack, and YYPTR gives the new location of the
532  stack. Advance YYPTR to a properly aligned location for the next
533  stack. */
534 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
535  do \
536  { \
537  YYSIZE_T yynewbytes; \
538  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
539  Stack = &yyptr->Stack_alloc; \
540  yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
541  yyptr += yynewbytes / sizeof (*yyptr); \
542  } \
543  while (0)
544 
545 #endif
546 
547 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
548 /* Copy COUNT objects from SRC to DST. The source and destination do
549  not overlap. */
550 # ifndef YYCOPY
551 # if defined __GNUC__ && 1 < __GNUC__
552 # define YYCOPY(Dst, Src, Count) \
553  __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
554 # else
555 # define YYCOPY(Dst, Src, Count) \
556  do \
557  { \
558  YYSIZE_T yyi; \
559  for (yyi = 0; yyi < (Count); yyi++) \
560  (Dst)[yyi] = (Src)[yyi]; \
561  } \
562  while (0)
563 # endif
564 # endif
565 #endif /* !YYCOPY_NEEDED */
566 
567 /* YYFINAL -- State number of the termination state. */
568 #define YYFINAL 3
569 /* YYLAST -- Last index in YYTABLE. */
570 #define YYLAST 221
571 
572 /* YYNTOKENS -- Number of terminals. */
573 #define YYNTOKENS 86
574 /* YYNNTS -- Number of nonterminals. */
575 #define YYNNTS 59
576 /* YYNRULES -- Number of rules. */
577 #define YYNRULES 154
578 /* YYNSTATES -- Number of states. */
579 #define YYNSTATES 272
580 
581 /* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
582  by yylex, with out-of-bounds checking. */
583 #define YYUNDEFTOK 2
584 #define YYMAXUTOK 340
585 
586 #define YYTRANSLATE(YYX) \
587  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
588 
589 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
590  as returned by yylex, without out-of-bounds checking. */
591 static const yytype_uint8 yytranslate[] =
592 {
593  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
595  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
608  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
609  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
610  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
611  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
612  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
613  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
614  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
615  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
616  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
617  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
618  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
619  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
620  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
621  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
622  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
623  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
624  55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
625  65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
626  75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
627  85
628 };
629 
630 #if YYDEBUG
631  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
632 static const yytype_uint16 yyrline[] =
633 {
634  0, 156, 156, 159, 161, 169, 171, 173, 175, 177,
635  179, 181, 183, 186, 185, 189, 188, 191, 194, 193,
636  196, 200, 203, 202, 208, 210, 213, 212, 217, 216,
637  220, 219, 223, 222, 226, 225, 229, 228, 232, 231,
638  236, 238, 243, 245, 247, 250, 252, 257, 259, 261,
639  263, 265, 267, 269, 273, 275, 277, 279, 281, 285,
640  287, 292, 294, 297, 296, 299, 304, 303, 310, 312,
641  314, 316, 318, 320, 322, 327, 329, 334, 336, 342,
642  344, 349, 351, 353, 355, 357, 359, 362, 364, 369,
643  371, 373, 375, 377, 379, 381, 383, 389, 391, 397,
644  396, 399, 402, 404, 409, 411, 414, 416, 422, 421,
645  424, 427, 429, 434, 436, 439, 441, 447, 446, 449,
646  452, 454, 459, 461, 464, 466, 472, 471, 474, 477,
647  479, 484, 486, 489, 491, 497, 496, 499, 502, 504,
648  509, 511, 514, 516, 522, 521, 524, 527, 529, 534,
649  536, 538, 540, 542, 544
650 };
651 #endif
652 
653 #if YYDEBUG || YYERROR_VERBOSE || 0
654 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
655  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
656 static const char *const yytname[] =
657 {
658  "$end", "error", "$undefined", "LEFT", "RIGHT", "NUMBER", "FIX",
659  "COMMENT", "CHECKSUM", "DESIGNSIZE", "DESIGNUNITS", "CODINGSCHEME",
660  "FAMILY", "FACE", "SEVENBITSAFEFLAG", "HEADER", "FONTDIMEN", "LIGTABLE",
661  "BOUNDARYCHAR", "CHARACTER", "NAMEDPARAMETER", "PARAMETER",
662  "CHARMEASURE", "NEXTLARGER", "VARCHAR", "EXTEN", "LABEL", "LIG", "KRN",
663  "STOP", "SKIP", "VTITLE", "MAPFONT", "FONTNAME", "FONTAREA",
664  "FONTCHECKSUM", "FONTAT", "FONTDSIZE", "MAP", "SELECTFONT", "SETCHAR",
665  "SETRULE", "MOVE", "PUSH", "POP", "SPECIAL", "SPECIALHEX", "CHARREPEAT",
666  "FONTIVALUE", "FONTFVALUE", "FONTMVALUE", "FONTPENALTY", "FONTRULE",
667  "FONTGLUE", "CLABEL", "CKRN", "CGLUE", "CPENALTY", "CPENGLUE",
668  "CHARIVALUE", "CHARFVALUE", "CHARMVALUE", "CHARPENALTY", "CHARRULE",
669  "CHARGLUE", "IVALUE", "IVALUEVAL", "MVALUE", "MVALUEVAL", "FVALUE",
670  "FVALUEVAL", "PENALTY", "PENALTYVAL", "RULE", "RULEMEASURE", "GLUE",
671  "GLUEWD", "GLUETYPE", "GLUEKIND", "GLUERULE", "GLUECHAR",
672  "GLUESHRINKSTRETCH", "GLUEORDER", "OFMLEVEL", "FONTDIR", "ACCENT",
673  "$accept", "File", "Entries", "OneEntry", "$@1", "$@2", "$@3", "$@4",
674  "$@5", "$@6", "$@7", "$@8", "$@9", "$@10", "$@11", "FontParameters",
675  "OneFontParameter", "LigKernEntries", "OneLigKernEntry",
676  "CharacterEntries", "OneCharacterEntry", "$@12", "$@13",
677  "VarCharParameters", "OneVarCharParameter", "MapFontEntries",
678  "OneMapFontEntry", "MapEntries", "OneMapEntry", "FontIvalueEntries",
679  "OneFontIvalueEntry", "$@14", "IvalueDefinition", "OneIvalueDefinition",
680  "FontMvalueEntries", "OneFontMvalueEntry", "$@15", "MvalueDefinition",
681  "OneMvalueDefinition", "FontFvalueEntries", "OneFontFvalueEntry", "$@16",
682  "FvalueDefinition", "OneFvalueDefinition", "FontPenaltyEntries",
683  "OneFontPenaltyEntry", "$@17", "PenaltyDefinition",
684  "OnePenaltyDefinition", "FontRuleEntries", "OneFontRuleEntry", "$@18",
685  "RuleDefinition", "OneRuleDefinition", "FontGlueEntries",
686  "OneFontGlueEntry", "$@19", "GlueDefinition", "OneGlueDefinition", YY_NULLPTR
687 };
688 #endif
689 
690 # ifdef YYPRINT
691 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
692  (internal) symbol number NUM (which must be that of a token). */
693 static const yytype_uint16 yytoknum[] =
694 {
695  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
696  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
697  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
698  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
699  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
700  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
701  315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
702  325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
703  335, 336, 337, 338, 339, 340
704 };
705 # endif
706 
707 #define YYPACT_NINF -8
708 
709 #define yypact_value_is_default(Yystate) \
710  (!!((Yystate) == (-8)))
711 
712 #define YYTABLE_NINF -1
713 
714 #define yytable_value_is_error(Yytable_value) \
715  0
716 
717  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
718  STATE-NUM. */
719 static const yytype_int16 yypact[] =
720 {
721  -8, 8, 9, -8, 11, -8, 4, 5, 29, -8,
722  -8, 34, -8, 35, -8, -8, 36, 39, -8, 40,
723  41, 44, 46, 76, 77, 79, 81, 82, -8, 10,
724  -8, -8, -8, -8, 83, -8, -8, -8, -8, -8,
725  84, -8, -8, -8, -8, -8, -8, -8, -8, -8,
726  33, 80, -8, -8, -8, -8, -8, -8, -8, -8,
727  -8, 27, 72, 87, 88, -8, 89, 101, 102, 108,
728  109, 118, -8, 116, 119, 121, -8, 32, 126, 127,
729  -8, 128, 129, 130, 131, 132, 133, 135, -7, 73,
730  87, 0, -2, -1, 6, 3, -3, -8, 117, -8,
731  -8, -8, 136, 134, -8, -8, 137, 139, 140, 141,
732  -8, -8, 142, 144, -8, -8, 145, 146, 147, 148,
733  149, 150, -8, 138, -8, -8, -8, 151, 152, 153,
734  143, -8, 155, 157, -8, 158, 160, -8, 161, 163,
735  -8, 164, 166, -8, 167, 169, -8, 170, 172, -8,
736  -8, -8, -8, -8, -8, 173, -8, -8, -8, -8,
737  174, 175, 176, 177, 178, 179, -8, -8, -8, -8,
738  -8, -8, -8, -8, -8, -8, -8, -8, -8, -8,
739  -8, -8, -8, -8, 154, 159, -8, -8, -8, -8,
740  -8, -8, -8, -8, -8, -8, -8, -8, 78, 74,
741  162, 165, 168, 171, 182, 183, -8, 184, 186, 187,
742  188, 181, 185, -8, -8, -8, -8, 190, 31, 26,
743  25, -4, -5, -6, -8, -8, -8, -8, 189, -8,
744  -8, -8, 191, 193, -8, 192, 195, -8, 194, 197,
745  -8, 198, 200, -8, 196, 201, -8, 202, 99, 204,
746  205, 206, 203, -8, -8, -8, -8, -8, -8, -8,
747  -8, -8, -8, -8, -8, -8, 208, -8, 106, -8,
748  -8, -8
749 };
750 
751  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
752  Performed when YYTABLE does not specify something else to do. Zero
753  means the default is an error. */
754 static const yytype_uint8 yydefact[] =
755 {
756  3, 0, 2, 1, 0, 20, 0, 0, 0, 8,
757  9, 0, 11, 0, 13, 15, 0, 0, 21, 0,
758  0, 0, 0, 0, 0, 0, 0, 0, 25, 0,
759  5, 6, 7, 10, 0, 40, 45, 17, 18, 22,
760  0, 28, 32, 30, 34, 36, 38, 24, 4, 12,
761  14, 16, 59, 79, 26, 97, 115, 106, 124, 133,
762  142, 0, 0, 19, 23, 59, 29, 33, 31, 35,
763  37, 39, 44, 0, 0, 0, 53, 0, 0, 0,
764  51, 0, 0, 0, 0, 0, 0, 0, 0, 0,
765  27, 0, 0, 0, 0, 0, 0, 42, 0, 41,
766  47, 48, 0, 0, 52, 54, 0, 0, 0, 0,
767  46, 65, 0, 0, 63, 66, 0, 0, 0, 0,
768  0, 0, 68, 0, 86, 81, 82, 0, 0, 0,
769  0, 101, 0, 0, 119, 0, 0, 110, 0, 0,
770  128, 0, 0, 137, 0, 0, 146, 0, 0, 43,
771  49, 50, 55, 56, 57, 0, 61, 62, 75, 87,
772  0, 0, 0, 0, 0, 0, 60, 83, 84, 85,
773  80, 99, 98, 117, 116, 108, 107, 126, 125, 135,
774  134, 144, 143, 58, 64, 67, 69, 71, 70, 72,
775  73, 74, 102, 120, 111, 129, 138, 147, 0, 0,
776  100, 118, 109, 127, 136, 145, 78, 0, 0, 0,
777  0, 0, 0, 93, 94, 95, 96, 0, 0, 0,
778  0, 0, 0, 0, 77, 76, 89, 90, 0, 92,
779  88, 105, 0, 0, 123, 0, 0, 114, 0, 0,
780  132, 0, 0, 141, 0, 0, 154, 0, 0, 0,
781  0, 0, 0, 91, 104, 103, 122, 121, 113, 112,
782  131, 130, 140, 139, 150, 149, 0, 151, 0, 148,
783  152, 153
784 };
785 
786  /* YYPGOTO[NTERM-NUM]. */
787 static const yytype_int16 yypgoto[] =
788 {
789  -8, -8, -8, -8, -8, -8, -8, -8, -8, -8,
790  -8, -8, -8, -8, -8, -8, -8, -8, -8, 156,
791  -8, -8, -8, -8, -8, -8, -8, -8, -8, -8,
792  -8, -8, -8, -8, -8, -8, -8, -8, -8, -8,
793  -8, -8, -8, -8, -8, -8, -8, -8, -8, -8,
794  -8, -8, -8, -8, -8, -8, -8, -8, -8
795 };
796 
797  /* YYDEFGOTO[NTERM-NUM]. */
798 static const yytype_int16 yydefgoto[] =
799 {
800  -1, 1, 2, 29, 35, 36, 52, 53, 65, 55,
801  57, 56, 58, 59, 60, 50, 75, 51, 87, 63,
802  123, 158, 159, 184, 208, 64, 130, 185, 217, 66,
803  133, 192, 200, 233, 68, 139, 194, 202, 239, 67,
804  136, 193, 201, 236, 69, 142, 195, 203, 242, 70,
805  145, 196, 204, 245, 71, 148, 197, 205, 252
806 };
807 
808  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
809  positive, shift that token. If negative, reduce the rule whose
810  number is the opposite. If YYTABLE_NINF, syntax error. */
811 static const yytype_uint16 yytable[] =
812 {
813  111, 246, 243, 240, 146, 134, 137, 131, 3, 30,
814  143, 31, 4, 140, 48, 112, 113, 114, 5, 6,
815  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
816  17, 115, 237, 234, 72, 32, 61, 100, 231, 33,
817  34, 37, 18, 19, 38, 39, 40, 73, 74, 41,
818  101, 42, 116, 117, 118, 119, 120, 121, 20, 21,
819  22, 23, 24, 25, 26, 132, 138, 135, 241, 244,
820  247, 248, 147, 249, 250, 251, 144, 141, 122, 76,
821  124, 43, 44, 62, 45, 206, 46, 47, 49, 54,
822  88, 89, 91, 238, 27, 28, 235, 232, 77, 78,
823  79, 80, 81, 207, 92, 93, 125, 126, 127, 128,
824  129, 94, 95, 209, 210, 211, 212, 213, 214, 215,
825  216, 96, 97, 149, 98, 99, 82, 83, 84, 85,
826  86, 102, 103, 104, 105, 106, 107, 108, 109, 110,
827  151, 150, 166, 152, 153, 154, 155, 170, 156, 157,
828  160, 161, 162, 163, 164, 165, 167, 198, 168, 169,
829  171, 172, 199, 173, 174, 218, 175, 176, 219, 177,
830  178, 220, 179, 180, 221, 181, 182, 265, 183, 186,
831  187, 188, 189, 190, 191, 222, 223, 228, 271, 224,
832  225, 229, 226, 227, 230, 253, 254, 255, 256, 257,
833  258, 259, 262, 260, 261, 263, 0, 269, 264, 266,
834  267, 0, 268, 270, 0, 0, 0, 0, 0, 0,
835  0, 90
836 };
837 
838 static const yytype_int8 yycheck[] =
839 {
840  7, 7, 7, 7, 7, 7, 7, 7, 0, 5,
841  7, 6, 3, 7, 4, 22, 23, 24, 7, 8,
842  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
843  19, 38, 7, 7, 7, 6, 3, 5, 7, 5,
844  5, 5, 31, 32, 5, 5, 5, 20, 21, 5,
845  18, 5, 59, 60, 61, 62, 63, 64, 47, 48,
846  49, 50, 51, 52, 53, 65, 67, 69, 72, 74,
847  76, 77, 75, 79, 80, 81, 73, 71, 85, 7,
848  7, 5, 5, 3, 5, 7, 5, 5, 5, 5,
849  3, 3, 3, 68, 83, 84, 70, 66, 26, 27,
850  28, 29, 30, 25, 3, 3, 33, 34, 35, 36,
851  37, 3, 3, 39, 40, 41, 42, 43, 44, 45,
852  46, 3, 6, 6, 5, 4, 54, 55, 56, 57,
853  58, 5, 5, 5, 5, 5, 5, 5, 5, 4,
854  6, 5, 4, 6, 5, 5, 5, 4, 6, 5,
855  5, 5, 5, 5, 5, 5, 5, 3, 6, 6,
856  5, 4, 3, 5, 4, 3, 5, 4, 3, 5,
857  4, 3, 5, 4, 3, 5, 4, 78, 5, 5,
858  5, 5, 5, 5, 5, 3, 3, 6, 82, 5,
859  4, 6, 5, 5, 4, 6, 5, 4, 6, 4,
860  6, 4, 6, 5, 4, 4, -1, 4, 6, 5,
861  5, -1, 6, 5, -1, -1, -1, -1, -1, -1,
862  -1, 65
863 };
864 
865  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
866  symbol of state STATE-NUM. */
867 static const yytype_uint8 yystos[] =
868 {
869  0, 87, 88, 0, 3, 7, 8, 9, 10, 11,
870  12, 13, 14, 15, 16, 17, 18, 19, 31, 32,
871  47, 48, 49, 50, 51, 52, 53, 83, 84, 89,
872  5, 6, 6, 5, 5, 90, 91, 5, 5, 5,
873  5, 5, 5, 5, 5, 5, 5, 5, 4, 5,
874  101, 103, 92, 93, 5, 95, 97, 96, 98, 99,
875  100, 3, 3, 105, 111, 94, 115, 125, 120, 130,
876  135, 140, 7, 20, 21, 102, 7, 26, 27, 28,
877  29, 30, 54, 55, 56, 57, 58, 104, 3, 3,
878  105, 3, 3, 3, 3, 3, 3, 6, 5, 4,
879  5, 18, 5, 5, 5, 5, 5, 5, 5, 5,
880  4, 7, 22, 23, 24, 38, 59, 60, 61, 62,
881  63, 64, 85, 106, 7, 33, 34, 35, 36, 37,
882  112, 7, 65, 116, 7, 69, 126, 7, 67, 121,
883  7, 71, 131, 7, 73, 136, 7, 75, 141, 6,
884  5, 6, 6, 5, 5, 5, 6, 5, 107, 108,
885  5, 5, 5, 5, 5, 5, 4, 5, 6, 6,
886  4, 5, 4, 5, 4, 5, 4, 5, 4, 5,
887  4, 5, 4, 5, 109, 113, 5, 5, 5, 5,
888  5, 5, 117, 127, 122, 132, 137, 142, 3, 3,
889  118, 128, 123, 133, 138, 143, 7, 25, 110, 39,
890  40, 41, 42, 43, 44, 45, 46, 114, 3, 3,
891  3, 3, 3, 3, 5, 4, 5, 5, 6, 6,
892  4, 7, 66, 119, 7, 70, 129, 7, 68, 124,
893  7, 72, 134, 7, 74, 139, 7, 76, 77, 79,
894  80, 81, 144, 6, 5, 4, 6, 4, 6, 4,
895  5, 4, 6, 4, 6, 78, 5, 5, 6, 4,
896  5, 82
897 };
898 
899  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
900 static const yytype_uint8 yyr1[] =
901 {
902  0, 86, 87, 88, 88, 89, 89, 89, 89, 89,
903  89, 89, 89, 90, 89, 91, 89, 89, 92, 89,
904  89, 89, 93, 89, 89, 89, 94, 89, 95, 89,
905  96, 89, 97, 89, 98, 89, 99, 89, 100, 89,
906  101, 101, 102, 102, 102, 103, 103, 104, 104, 104,
907  104, 104, 104, 104, 104, 104, 104, 104, 104, 105,
908  105, 106, 106, 107, 106, 106, 108, 106, 106, 106,
909  106, 106, 106, 106, 106, 109, 109, 110, 110, 111,
910  111, 112, 112, 112, 112, 112, 112, 113, 113, 114,
911  114, 114, 114, 114, 114, 114, 114, 115, 115, 117,
912  116, 116, 118, 118, 119, 119, 120, 120, 122, 121,
913  121, 123, 123, 124, 124, 125, 125, 127, 126, 126,
914  128, 128, 129, 129, 130, 130, 132, 131, 131, 133,
915  133, 134, 134, 135, 135, 137, 136, 136, 138, 138,
916  139, 139, 140, 140, 142, 141, 141, 143, 143, 144,
917  144, 144, 144, 144, 144
918 };
919 
920  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
921 static const yytype_uint8 yyr2[] =
922 {
923  0, 2, 1, 0, 4, 2, 2, 2, 1, 1,
924  2, 1, 3, 0, 3, 0, 3, 2, 0, 4,
925  1, 1, 0, 4, 2, 1, 0, 5, 0, 4,
926  0, 4, 0, 4, 0, 4, 0, 4, 0, 4,
927  0, 4, 2, 3, 1, 0, 4, 2, 2, 3,
928  3, 1, 2, 1, 2, 3, 3, 3, 4, 0,
929  4, 2, 2, 0, 3, 1, 0, 3, 1, 3,
930  3, 3, 3, 3, 3, 0, 4, 2, 1, 0,
931  4, 1, 1, 2, 2, 2, 1, 0, 4, 2,
932  2, 3, 2, 1, 1, 1, 1, 0, 4, 0,
933  4, 1, 0, 4, 2, 1, 0, 4, 0, 4,
934  1, 0, 4, 2, 1, 0, 4, 0, 4, 1,
935  0, 4, 2, 1, 0, 4, 0, 4, 1, 0,
936  4, 2, 1, 0, 4, 0, 4, 1, 0, 4,
937  2, 1, 0, 4, 0, 4, 1, 0, 4, 2,
938  2, 2, 3, 3, 1
939 };
940 
941 
942 #define yyerrok (yyerrstatus = 0)
943 #define yyclearin (yychar = YYEMPTY)
944 #define YYEMPTY (-2)
945 #define YYEOF 0
946 
947 #define YYACCEPT goto yyacceptlab
948 #define YYABORT goto yyabortlab
949 #define YYERROR goto yyerrorlab
950 
951 
952 #define YYRECOVERING() (!!yyerrstatus)
953 
954 #define YYBACKUP(Token, Value) \
955 do \
956  if (yychar == YYEMPTY) \
957  { \
958  yychar = (Token); \
959  yylval = (Value); \
960  YYPOPSTACK (yylen); \
961  yystate = *yyssp; \
962  goto yybackup; \
963  } \
964  else \
965  { \
966  yyerror (YY_("syntax error: cannot back up")); \
967  YYERROR; \
968  } \
969 while (0)
970 
971 /* Error token number */
972 #define YYTERROR 1
973 #define YYERRCODE 256
974 
975 
976 
977 /* Enable debugging if requested. */
978 #if YYDEBUG
979 
980 # ifndef YYFPRINTF
981 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
982 # define YYFPRINTF fprintf
983 # endif
984 
985 # define YYDPRINTF(Args) \
986 do { \
987  if (yydebug) \
988  YYFPRINTF Args; \
989 } while (0)
990 
991 /* This macro is provided for backward compatibility. */
992 #ifndef YY_LOCATION_PRINT
993 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
994 #endif
995 
996 
997 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
998 do { \
999  if (yydebug) \
1000  { \
1001  YYFPRINTF (stderr, "%s ", Title); \
1002  yy_symbol_print (stderr, \
1003  Type, Value); \
1004  YYFPRINTF (stderr, "\n"); \
1005  } \
1006 } while (0)
1007 
1008 
1009 /*----------------------------------------.
1010 | Print this symbol's value on YYOUTPUT. |
1011 `----------------------------------------*/
1012 
1013 static void
1014 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1015 {
1016  FILE *yyo = yyoutput;
1017  YYUSE (yyo);
1018  if (!yyvaluep)
1019  return;
1020 # ifdef YYPRINT
1021  if (yytype < YYNTOKENS)
1022  YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1023 # endif
1024  YYUSE (yytype);
1025 }
1026 
1027 
1028 /*--------------------------------.
1029 | Print this symbol on YYOUTPUT. |
1030 `--------------------------------*/
1031 
1032 static void
1033 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1034 {
1035  YYFPRINTF (yyoutput, "%s %s (",
1036  yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
1037 
1038  yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1039  YYFPRINTF (yyoutput, ")");
1040 }
1041 
1042 /*------------------------------------------------------------------.
1043 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1044 | TOP (included). |
1045 `------------------------------------------------------------------*/
1046 
1047 static void
1048 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1049 {
1050  YYFPRINTF (stderr, "Stack now");
1051  for (; yybottom <= yytop; yybottom++)
1052  {
1053  int yybot = *yybottom;
1054  YYFPRINTF (stderr, " %d", yybot);
1055  }
1056  YYFPRINTF (stderr, "\n");
1057 }
1058 
1059 # define YY_STACK_PRINT(Bottom, Top) \
1060 do { \
1061  if (yydebug) \
1062  yy_stack_print ((Bottom), (Top)); \
1063 } while (0)
1064 
1065 
1066 /*------------------------------------------------.
1067 | Report that the YYRULE is going to be reduced. |
1068 `------------------------------------------------*/
1069 
1070 static void
1071 yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
1072 {
1073  unsigned long int yylno = yyrline[yyrule];
1074  int yynrhs = yyr2[yyrule];
1075  int yyi;
1076  YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1077  yyrule - 1, yylno);
1078  /* The symbols being reduced. */
1079  for (yyi = 0; yyi < yynrhs; yyi++)
1080  {
1081  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1082  yy_symbol_print (stderr,
1083  yystos[yyssp[yyi + 1 - yynrhs]],
1084  &(yyvsp[(yyi + 1) - (yynrhs)])
1085  );
1086  YYFPRINTF (stderr, "\n");
1087  }
1088 }
1089 
1090 # define YY_REDUCE_PRINT(Rule) \
1091 do { \
1092  if (yydebug) \
1093  yy_reduce_print (yyssp, yyvsp, Rule); \
1094 } while (0)
1095 
1096 /* Nonzero means print parse trace. It is left uninitialized so that
1097  multiple parsers can coexist. */
1098 int yydebug;
1099 #else /* !YYDEBUG */
1100 # define YYDPRINTF(Args)
1101 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1102 # define YY_STACK_PRINT(Bottom, Top)
1103 # define YY_REDUCE_PRINT(Rule)
1104 #endif /* !YYDEBUG */
1105 
1106 
1107 /* YYINITDEPTH -- initial size of the parser's stacks. */
1108 #ifndef YYINITDEPTH
1109 # define YYINITDEPTH 200
1110 #endif
1111 
1112 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1113  if the built-in stack extension method is used).
1114 
1115  Do not make this value too large; the results are undefined if
1116  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1117  evaluated with infinite-precision integer arithmetic. */
1118 
1119 #ifndef YYMAXDEPTH
1120 # define YYMAXDEPTH 10000
1121 #endif
1122 
1123 
1124 #if YYERROR_VERBOSE
1125 
1126 # ifndef yystrlen
1127 # if defined __GLIBC__ && defined _STRING_H
1128 # define yystrlen strlen
1129 # else
1130 /* Return the length of YYSTR. */
1131 static YYSIZE_T
1132 yystrlen (const char *yystr)
1133 {
1134  YYSIZE_T yylen;
1135  for (yylen = 0; yystr[yylen]; yylen++)
1136  continue;
1137  return yylen;
1138 }
1139 # endif
1140 # endif
1141 
1142 # ifndef yystpcpy
1143 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1144 # define yystpcpy stpcpy
1145 # else
1146 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1147  YYDEST. */
1148 static char *
1149 yystpcpy (char *yydest, const char *yysrc)
1150 {
1151  char *yyd = yydest;
1152  const char *yys = yysrc;
1153 
1154  while ((*yyd++ = *yys++) != '\0')
1155  continue;
1156 
1157  return yyd - 1;
1158 }
1159 # endif
1160 # endif
1161 
1162 # ifndef yytnamerr
1163 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1164  quotes and backslashes, so that it's suitable for yyerror. The
1165  heuristic is that double-quoting is unnecessary unless the string
1166  contains an apostrophe, a comma, or backslash (other than
1167  backslash-backslash). YYSTR is taken from yytname. If YYRES is
1168  null, do not copy; instead, return the length of what the result
1169  would have been. */
1170 static YYSIZE_T
1171 yytnamerr (char *yyres, const char *yystr)
1172 {
1173  if (*yystr == '"')
1174  {
1175  YYSIZE_T yyn = 0;
1176  char const *yyp = yystr;
1177 
1178  for (;;)
1179  switch (*++yyp)
1180  {
1181  case '\'':
1182  case ',':
1183  goto do_not_strip_quotes;
1184 
1185  case '\\':
1186  if (*++yyp != '\\')
1187  goto do_not_strip_quotes;
1188  /* Fall through. */
1189  default:
1190  if (yyres)
1191  yyres[yyn] = *yyp;
1192  yyn++;
1193  break;
1194 
1195  case '"':
1196  if (yyres)
1197  yyres[yyn] = '\0';
1198  return yyn;
1199  }
1200  do_not_strip_quotes: ;
1201  }
1202 
1203  if (! yyres)
1204  return yystrlen (yystr);
1205 
1206  return yystpcpy (yyres, yystr) - yyres;
1207 }
1208 # endif
1209 
1210 /* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1211  about the unexpected token YYTOKEN for the state stack whose top is
1212  YYSSP.
1213 
1214  Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
1215  not large enough to hold the message. In that case, also set
1216  *YYMSG_ALLOC to the required number of bytes. Return 2 if the
1217  required number of bytes is too large to store. */
1218 static int
1219 yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
1220  yytype_int16 *yyssp, int yytoken)
1221 {
1222  YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1223  YYSIZE_T yysize = yysize0;
1224  enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
1225  /* Internationalized format string. */
1226  const char *yyformat = YY_NULLPTR;
1227  /* Arguments of yyformat. */
1228  char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
1229  /* Number of reported tokens (one for the "unexpected", one per
1230  "expected"). */
1231  int yycount = 0;
1232 
1233  /* There are many possibilities here to consider:
1234  - If this state is a consistent state with a default action, then
1235  the only way this function was invoked is if the default action
1236  is an error action. In that case, don't check for expected
1237  tokens because there are none.
1238  - The only way there can be no lookahead present (in yychar) is if
1239  this state is a consistent state with a default action. Thus,
1240  detecting the absence of a lookahead is sufficient to determine
1241  that there is no unexpected or expected token to report. In that
1242  case, just report a simple "syntax error".
1243  - Don't assume there isn't a lookahead just because this state is a
1244  consistent state with a default action. There might have been a
1245  previous inconsistent state, consistent state with a non-default
1246  action, or user semantic action that manipulated yychar.
1247  - Of course, the expected token list depends on states to have
1248  correct lookahead information, and it depends on the parser not
1249  to perform extra reductions after fetching a lookahead from the
1250  scanner and before detecting a syntax error. Thus, state merging
1251  (from LALR or IELR) and default reductions corrupt the expected
1252  token list. However, the list is correct for canonical LR with
1253  one exception: it will still contain any token that will not be
1254  accepted due to an error action in a later state.
1255  */
1256  if (yytoken != YYEMPTY)
1257  {
1258  int yyn = yypact[*yyssp];
1259  yyarg[yycount++] = yytname[yytoken];
1260  if (!yypact_value_is_default (yyn))
1261  {
1262  /* Start YYX at -YYN if negative to avoid negative indexes in
1263  YYCHECK. In other words, skip the first -YYN actions for
1264  this state because they are default actions. */
1265  int yyxbegin = yyn < 0 ? -yyn : 0;
1266  /* Stay within bounds of both yycheck and yytname. */
1267  int yychecklim = YYLAST - yyn + 1;
1268  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1269  int yyx;
1270 
1271  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1272  if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1273  && !yytable_value_is_error (yytable[yyx + yyn]))
1274  {
1275  if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1276  {
1277  yycount = 1;
1278  yysize = yysize0;
1279  break;
1280  }
1281  yyarg[yycount++] = yytname[yyx];
1282  {
1283  YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1284  if (! (yysize <= yysize1
1285  && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1286  return 2;
1287  yysize = yysize1;
1288  }
1289  }
1290  }
1291  }
1292 
1293  switch (yycount)
1294  {
1295 # define YYCASE_(N, S) \
1296  case N: \
1297  yyformat = S; \
1298  break
1299  YYCASE_(0, YY_("syntax error"));
1300  YYCASE_(1, YY_("syntax error, unexpected %s"));
1301  YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1302  YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1303  YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1304  YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1305 # undef YYCASE_
1306  }
1307 
1308  {
1309  YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
1310  if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
1311  return 2;
1312  yysize = yysize1;
1313  }
1314 
1315  if (*yymsg_alloc < yysize)
1316  {
1317  *yymsg_alloc = 2 * yysize;
1318  if (! (yysize <= *yymsg_alloc
1319  && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1320  *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1321  return 1;
1322  }
1323 
1324  /* Avoid sprintf, as that infringes on the user's name space.
1325  Don't have undefined behavior even if the translation
1326  produced a string with the wrong number of "%s"s. */
1327  {
1328  char *yyp = *yymsg;
1329  int yyi = 0;
1330  while ((*yyp = *yyformat) != '\0')
1331  if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
1332  {
1333  yyp += yytnamerr (yyp, yyarg[yyi++]);
1334  yyformat += 2;
1335  }
1336  else
1337  {
1338  yyp++;
1339  yyformat++;
1340  }
1341  }
1342  return 0;
1343 }
1344 #endif /* YYERROR_VERBOSE */
1345 
1346 /*-----------------------------------------------.
1347 | Release the memory associated to this symbol. |
1348 `-----------------------------------------------*/
1349 
1350 static void
1351 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
1352 {
1353  YYUSE (yyvaluep);
1354  if (!yymsg)
1355  yymsg = "Deleting";
1356  YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1357 
1359  YYUSE (yytype);
1361 }
1362 
1363 
1364 
1365 
1366 /* The lookahead symbol. */
1368 
1369 /* The semantic value of the lookahead symbol. */
1371 /* Number of syntax errors so far. */
1373 
1374 
1375 /*----------.
1376 | yyparse. |
1377 `----------*/
1378 
1379 int
1380 yyparse (void)
1381 {
1382  int yystate;
1383  /* Number of tokens to shift before error messages enabled. */
1384  int yyerrstatus;
1385 
1386  /* The stacks and their tools:
1387  'yyss': related to states.
1388  'yyvs': related to semantic values.
1389 
1390  Refer to the stacks through separate pointers, to allow yyoverflow
1391  to reallocate them elsewhere. */
1392 
1393  /* The state stack. */
1394  yytype_int16 yyssa[YYINITDEPTH];
1395  yytype_int16 *yyss;
1396  yytype_int16 *yyssp;
1397 
1398  /* The semantic value stack. */
1399  YYSTYPE yyvsa[YYINITDEPTH];
1400  YYSTYPE *yyvs;
1401  YYSTYPE *yyvsp;
1402 
1403  YYSIZE_T yystacksize;
1404 
1405  int yyn;
1406  int yyresult;
1407  /* Lookahead token as an internal (translated) token number. */
1408  int yytoken = 0;
1409  /* The variables used to return semantic value and location from the
1410  action routines. */
1411  YYSTYPE yyval;
1412 
1413 #if YYERROR_VERBOSE
1414  /* Buffer for error messages, and its allocated size. */
1415  char yymsgbuf[128];
1416  char *yymsg = yymsgbuf;
1417  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1418 #endif
1419 
1420 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1421 
1422  /* The number of symbols on the RHS of the reduced rule.
1423  Keep to zero when no symbol should be popped. */
1424  int yylen = 0;
1425 
1426  yyssp = yyss = yyssa;
1427  yyvsp = yyvs = yyvsa;
1428  yystacksize = YYINITDEPTH;
1429 
1430  YYDPRINTF ((stderr, "Starting parse\n"));
1431 
1432  yystate = 0;
1433  yyerrstatus = 0;
1434  yynerrs = 0;
1435  yychar = YYEMPTY; /* Cause a token to be read. */
1436  goto yysetstate;
1437 
1438 /*------------------------------------------------------------.
1439 | yynewstate -- Push a new state, which is found in yystate. |
1440 `------------------------------------------------------------*/
1441  yynewstate:
1442  /* In all cases, when you get here, the value and location stacks
1443  have just been pushed. So pushing a state here evens the stacks. */
1444  yyssp++;
1445 
1446  yysetstate:
1447  *yyssp = yystate;
1448 
1449  if (yyss + yystacksize - 1 <= yyssp)
1450  {
1451  /* Get the current used size of the three stacks, in elements. */
1452  YYSIZE_T yysize = yyssp - yyss + 1;
1453 
1454 #ifdef yyoverflow
1455  {
1456  /* Give user a chance to reallocate the stack. Use copies of
1457  these so that the &'s don't force the real ones into
1458  memory. */
1459  YYSTYPE *yyvs1 = yyvs;
1460  yytype_int16 *yyss1 = yyss;
1461 
1462  /* Each stack pointer address is followed by the size of the
1463  data in use in that stack, in bytes. This used to be a
1464  conditional around just the two extra args, but that might
1465  be undefined if yyoverflow is a macro. */
1466  yyoverflow (YY_("memory exhausted"),
1467  &yyss1, yysize * sizeof (*yyssp),
1468  &yyvs1, yysize * sizeof (*yyvsp),
1469  &yystacksize);
1470 
1471  yyss = yyss1;
1472  yyvs = yyvs1;
1473  }
1474 #else /* no yyoverflow */
1475 # ifndef YYSTACK_RELOCATE
1476  goto yyexhaustedlab;
1477 # else
1478  /* Extend the stack our own way. */
1479  if (YYMAXDEPTH <= yystacksize)
1480  goto yyexhaustedlab;
1481  yystacksize *= 2;
1482  if (YYMAXDEPTH < yystacksize)
1483  yystacksize = YYMAXDEPTH;
1484 
1485  {
1486  yytype_int16 *yyss1 = yyss;
1487  union yyalloc *yyptr =
1488  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1489  if (! yyptr)
1490  goto yyexhaustedlab;
1491  YYSTACK_RELOCATE (yyss_alloc, yyss);
1492  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1493 # undef YYSTACK_RELOCATE
1494  if (yyss1 != yyssa)
1495  YYSTACK_FREE (yyss1);
1496  }
1497 # endif
1498 #endif /* no yyoverflow */
1499 
1500  yyssp = yyss + yysize - 1;
1501  yyvsp = yyvs + yysize - 1;
1502 
1503  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1504  (unsigned long int) yystacksize));
1505 
1506  if (yyss + yystacksize - 1 <= yyssp)
1507  YYABORT;
1508  }
1509 
1510  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1511 
1512  if (yystate == YYFINAL)
1513  YYACCEPT;
1514 
1515  goto yybackup;
1516 
1517 /*-----------.
1518 | yybackup. |
1519 `-----------*/
1520 yybackup:
1521 
1522  /* Do appropriate processing given the current state. Read a
1523  lookahead token if we need one and don't already have one. */
1524 
1525  /* First try to decide what to do without reference to lookahead token. */
1526  yyn = yypact[yystate];
1527  if (yypact_value_is_default (yyn))
1528  goto yydefault;
1529 
1530  /* Not known => get a lookahead token if don't already have one. */
1531 
1532  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1533  if (yychar == YYEMPTY)
1534  {
1535  YYDPRINTF ((stderr, "Reading a token: "));
1536  yychar = yylex ();
1537  }
1538 
1539  if (yychar <= YYEOF)
1540  {
1541  yychar = yytoken = YYEOF;
1542  YYDPRINTF ((stderr, "Now at end of input.\n"));
1543  }
1544  else
1545  {
1546  yytoken = YYTRANSLATE (yychar);
1547  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1548  }
1549 
1550  /* If the proper action on seeing token YYTOKEN is to reduce or to
1551  detect an error, take that action. */
1552  yyn += yytoken;
1553  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1554  goto yydefault;
1555  yyn = yytable[yyn];
1556  if (yyn <= 0)
1557  {
1558  if (yytable_value_is_error (yyn))
1559  goto yyerrlab;
1560  yyn = -yyn;
1561  goto yyreduce;
1562  }
1563 
1564  /* Count tokens shifted since error; after three, turn off error
1565  status. */
1566  if (yyerrstatus)
1567  yyerrstatus--;
1568 
1569  /* Shift the lookahead token. */
1570  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1571 
1572  /* Discard the shifted token. */
1573  yychar = YYEMPTY;
1574 
1575  yystate = yyn;
1577  *++yyvsp = yylval;
1579 
1580  goto yynewstate;
1581 
1582 
1583 /*-----------------------------------------------------------.
1584 | yydefault -- do the default action for the current state. |
1585 `-----------------------------------------------------------*/
1586 yydefault:
1587  yyn = yydefact[yystate];
1588  if (yyn == 0)
1589  goto yyerrlab;
1590  goto yyreduce;
1591 
1592 
1593 /*-----------------------------.
1594 | yyreduce -- Do a reduction. |
1595 `-----------------------------*/
1596 yyreduce:
1597  /* yyn is the number of a rule to reduce with. */
1598  yylen = yyr2[yyn];
1599 
1600  /* If YYLEN is nonzero, implement the default value of the action:
1601  '$$ = $1'.
1602 
1603  Otherwise, the following line sets YYVAL to garbage.
1604  This behavior is undocumented and Bison
1605  users should not rely upon it. Assigning to YYVAL
1606  unconditionally makes the parser a bit smaller, and it avoids a
1607  GCC warning that YYVAL may be used uninitialized. */
1608  yyval = yyvsp[1-yylen];
1609 
1610 
1611  YY_REDUCE_PRINT (yyn);
1612  switch (yyn)
1613  {
1614  case 5:
1615 #line 170 "pl-parser.y" /* yacc.c:1646 */
1616  { set_check_sum((yyvsp[0]).yint); }
1617 #line 1618 "pl-parser.c" /* yacc.c:1646 */
1618  break;
1619 
1620  case 6:
1621 #line 172 "pl-parser.y" /* yacc.c:1646 */
1622  { set_design_size((yyvsp[0]).yfix); }
1623 #line 1624 "pl-parser.c" /* yacc.c:1646 */
1624  break;
1625 
1626  case 7:
1627 #line 174 "pl-parser.y" /* yacc.c:1646 */
1628  { set_design_units((yyvsp[0]).yfix); }
1629 #line 1630 "pl-parser.c" /* yacc.c:1646 */
1630  break;
1631 
1632  case 8:
1633 #line 176 "pl-parser.y" /* yacc.c:1646 */
1634  { set_coding_scheme((yyvsp[0]).ystring); }
1635 #line 1636 "pl-parser.c" /* yacc.c:1646 */
1636  break;
1637 
1638  case 9:
1639 #line 178 "pl-parser.y" /* yacc.c:1646 */
1640  { set_family((yyvsp[0]).ystring); }
1641 #line 1642 "pl-parser.c" /* yacc.c:1646 */
1642  break;
1643 
1644  case 10:
1645 #line 180 "pl-parser.y" /* yacc.c:1646 */
1646  { set_face((yyvsp[0]).yint); }
1647 #line 1648 "pl-parser.c" /* yacc.c:1646 */
1648  break;
1649 
1650  case 11:
1651 #line 182 "pl-parser.y" /* yacc.c:1646 */
1652  { set_seven_bit_safe_flag((yyvsp[0]).yint); }
1653 #line 1654 "pl-parser.c" /* yacc.c:1646 */
1654  break;
1655 
1656  case 12:
1657 #line 184 "pl-parser.y" /* yacc.c:1646 */
1658  { set_header_word((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1659 #line 1660 "pl-parser.c" /* yacc.c:1646 */
1660  break;
1661 
1662  case 13:
1663 #line 186 "pl-parser.y" /* yacc.c:1646 */
1664  { init_parameters(); }
1665 #line 1666 "pl-parser.c" /* yacc.c:1646 */
1666  break;
1667 
1668  case 15:
1669 #line 189 "pl-parser.y" /* yacc.c:1646 */
1670  { init_ligkern(); }
1671 #line 1672 "pl-parser.c" /* yacc.c:1646 */
1672  break;
1673 
1674  case 17:
1675 #line 192 "pl-parser.y" /* yacc.c:1646 */
1676  { set_boundary_character((yyvsp[0]).yint); }
1677 #line 1678 "pl-parser.c" /* yacc.c:1646 */
1678  break;
1679 
1680  case 18:
1681 #line 194 "pl-parser.y" /* yacc.c:1646 */
1682  { init_character((yyvsp[0]).yint, NULL); }
1683 #line 1684 "pl-parser.c" /* yacc.c:1646 */
1684  break;
1685 
1686  case 21:
1687 #line 201 "pl-parser.y" /* yacc.c:1646 */
1688  { set_vtitle((yyvsp[0]).ystring); }
1689 #line 1690 "pl-parser.c" /* yacc.c:1646 */
1690  break;
1691 
1692  case 22:
1693 #line 203 "pl-parser.y" /* yacc.c:1646 */
1694  { init_map_font((yyvsp[0]).yint); }
1695 #line 1696 "pl-parser.c" /* yacc.c:1646 */
1696  break;
1697 
1698  case 24:
1699 #line 209 "pl-parser.y" /* yacc.c:1646 */
1700  { set_ofm_level((yyvsp[0]).yint); }
1701 #line 1702 "pl-parser.c" /* yacc.c:1646 */
1702  break;
1703 
1704  case 25:
1705 #line 211 "pl-parser.y" /* yacc.c:1646 */
1706  { set_font_dir((yyvsp[0]).yint); }
1707 #line 1708 "pl-parser.c" /* yacc.c:1646 */
1708  break;
1709 
1710  case 26:
1711 #line 213 "pl-parser.y" /* yacc.c:1646 */
1712  { init_character((yyvsp[-1]).yint,NULL); }
1713 #line 1714 "pl-parser.c" /* yacc.c:1646 */
1714  break;
1715 
1716  case 27:
1717 #line 215 "pl-parser.y" /* yacc.c:1646 */
1718  { copy_characters((yyvsp[-3]).yint,(yyvsp[-2]).yint); }
1719 #line 1720 "pl-parser.c" /* yacc.c:1646 */
1720  break;
1721 
1722  case 28:
1723 #line 217 "pl-parser.y" /* yacc.c:1646 */
1724  {init_font_ivalue((yyvsp[0]).yint);}
1725 #line 1726 "pl-parser.c" /* yacc.c:1646 */
1726  break;
1727 
1728  case 30:
1729 #line 220 "pl-parser.y" /* yacc.c:1646 */
1730  { init_font_mvalue((yyvsp[0]).yint);}
1731 #line 1732 "pl-parser.c" /* yacc.c:1646 */
1732  break;
1733 
1734  case 32:
1735 #line 223 "pl-parser.y" /* yacc.c:1646 */
1736  { init_font_fvalue((yyvsp[0]).yint);}
1737 #line 1738 "pl-parser.c" /* yacc.c:1646 */
1738  break;
1739 
1740  case 34:
1741 #line 226 "pl-parser.y" /* yacc.c:1646 */
1742  { init_font_penalty((yyvsp[0]).yint);}
1743 #line 1744 "pl-parser.c" /* yacc.c:1646 */
1744  break;
1745 
1746  case 36:
1747 #line 229 "pl-parser.y" /* yacc.c:1646 */
1748  { init_font_rule((yyvsp[0]).yint);}
1749 #line 1750 "pl-parser.c" /* yacc.c:1646 */
1750  break;
1751 
1752  case 38:
1753 #line 232 "pl-parser.y" /* yacc.c:1646 */
1754  { init_font_glue((yyvsp[0]).yint);}
1755 #line 1756 "pl-parser.c" /* yacc.c:1646 */
1756  break;
1757 
1758  case 42:
1759 #line 244 "pl-parser.y" /* yacc.c:1646 */
1760  { set_param_word((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1761 #line 1762 "pl-parser.c" /* yacc.c:1646 */
1762  break;
1763 
1764  case 43:
1765 #line 246 "pl-parser.y" /* yacc.c:1646 */
1766  { set_param_word((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1767 #line 1768 "pl-parser.c" /* yacc.c:1646 */
1768  break;
1769 
1770  case 47:
1771 #line 258 "pl-parser.y" /* yacc.c:1646 */
1772  { set_label_command((yyvsp[0]).yint); }
1773 #line 1774 "pl-parser.c" /* yacc.c:1646 */
1774  break;
1775 
1776  case 48:
1777 #line 260 "pl-parser.y" /* yacc.c:1646 */
1779 #line 1780 "pl-parser.c" /* yacc.c:1646 */
1780  break;
1781 
1782  case 49:
1783 #line 262 "pl-parser.y" /* yacc.c:1646 */
1784  { set_ligature_command((yyvsp[-2]).yint, (yyvsp[-1]).yint, (yyvsp[0]).yint); }
1785 #line 1786 "pl-parser.c" /* yacc.c:1646 */
1786  break;
1787 
1788  case 50:
1789 #line 264 "pl-parser.y" /* yacc.c:1646 */
1790  { set_kerning_command((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1791 #line 1792 "pl-parser.c" /* yacc.c:1646 */
1792  break;
1793 
1794  case 51:
1795 #line 266 "pl-parser.y" /* yacc.c:1646 */
1796  { set_stop_command(); }
1797 #line 1798 "pl-parser.c" /* yacc.c:1646 */
1798  break;
1799 
1800  case 52:
1801 #line 268 "pl-parser.y" /* yacc.c:1646 */
1802  { set_skip_command((yyvsp[0]).yint); }
1803 #line 1804 "pl-parser.c" /* yacc.c:1646 */
1804  break;
1805 
1806  case 54:
1807 #line 274 "pl-parser.y" /* yacc.c:1646 */
1808  { set_c_label_command((yyvsp[0]).yint); }
1809 #line 1810 "pl-parser.c" /* yacc.c:1646 */
1810  break;
1811 
1812  case 55:
1813 #line 276 "pl-parser.y" /* yacc.c:1646 */
1814  { set_c_kerning_command((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1815 #line 1816 "pl-parser.c" /* yacc.c:1646 */
1816  break;
1817 
1818  case 56:
1819 #line 278 "pl-parser.y" /* yacc.c:1646 */
1820  { set_c_glue_command((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1821 #line 1822 "pl-parser.c" /* yacc.c:1646 */
1822  break;
1823 
1824  case 57:
1825 #line 280 "pl-parser.y" /* yacc.c:1646 */
1826  { set_c_penalty_command((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1827 #line 1828 "pl-parser.c" /* yacc.c:1646 */
1828  break;
1829 
1830  case 58:
1831 #line 282 "pl-parser.y" /* yacc.c:1646 */
1832  { set_c_penglue_command((yyvsp[-2]).yint, (yyvsp[-1]).yint, (yyvsp[0]).yint); }
1833 #line 1834 "pl-parser.c" /* yacc.c:1646 */
1834  break;
1835 
1836  case 61:
1837 #line 293 "pl-parser.y" /* yacc.c:1646 */
1838  { set_character_measure((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1839 #line 1840 "pl-parser.c" /* yacc.c:1646 */
1840  break;
1841 
1842  case 62:
1843 #line 295 "pl-parser.y" /* yacc.c:1646 */
1844  { set_next_larger((yyvsp[0]).yint); }
1845 #line 1846 "pl-parser.c" /* yacc.c:1646 */
1846  break;
1847 
1848  case 63:
1849 #line 297 "pl-parser.y" /* yacc.c:1646 */
1850  { init_var_character(); }
1851 #line 1852 "pl-parser.c" /* yacc.c:1646 */
1852  break;
1853 
1854  case 66:
1855 #line 304 "pl-parser.y" /* yacc.c:1646 */
1856  { init_map(); }
1857 #line 1858 "pl-parser.c" /* yacc.c:1646 */
1858  break;
1859 
1860  case 67:
1861 #line 306 "pl-parser.y" /* yacc.c:1646 */
1862  { end_map(); }
1863 #line 1864 "pl-parser.c" /* yacc.c:1646 */
1864  break;
1865 
1866  case 68:
1867 #line 311 "pl-parser.y" /* yacc.c:1646 */
1868  { set_accent((yyvsp[0]).yint); }
1869 #line 1870 "pl-parser.c" /* yacc.c:1646 */
1870  break;
1871 
1872  case 69:
1873 #line 313 "pl-parser.y" /* yacc.c:1646 */
1874  { set_character_ivalue((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1875 #line 1876 "pl-parser.c" /* yacc.c:1646 */
1876  break;
1877 
1878  case 70:
1879 #line 315 "pl-parser.y" /* yacc.c:1646 */
1880  { set_character_mvalue((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1881 #line 1882 "pl-parser.c" /* yacc.c:1646 */
1882  break;
1883 
1884  case 71:
1885 #line 317 "pl-parser.y" /* yacc.c:1646 */
1886  { set_character_fvalue((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1887 #line 1888 "pl-parser.c" /* yacc.c:1646 */
1888  break;
1889 
1890  case 72:
1891 #line 319 "pl-parser.y" /* yacc.c:1646 */
1892  { set_character_penalty((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1893 #line 1894 "pl-parser.c" /* yacc.c:1646 */
1894  break;
1895 
1896  case 73:
1897 #line 321 "pl-parser.y" /* yacc.c:1646 */
1898  { set_character_rule((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1899 #line 1900 "pl-parser.c" /* yacc.c:1646 */
1900  break;
1901 
1902  case 74:
1903 #line 323 "pl-parser.y" /* yacc.c:1646 */
1904  { set_character_glue((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1905 #line 1906 "pl-parser.c" /* yacc.c:1646 */
1906  break;
1907 
1908  case 77:
1909 #line 335 "pl-parser.y" /* yacc.c:1646 */
1910  { set_extensible_piece((yyvsp[-1]).yint, (yyvsp[0]).yint); }
1911 #line 1912 "pl-parser.c" /* yacc.c:1646 */
1912  break;
1913 
1914  case 81:
1915 #line 350 "pl-parser.y" /* yacc.c:1646 */
1916  { set_font_name((yyvsp[0]).ystring); }
1917 #line 1918 "pl-parser.c" /* yacc.c:1646 */
1918  break;
1919 
1920  case 82:
1921 #line 352 "pl-parser.y" /* yacc.c:1646 */
1922  { set_font_area((yyvsp[0]).ystring); }
1923 #line 1924 "pl-parser.c" /* yacc.c:1646 */
1924  break;
1925 
1926  case 83:
1927 #line 354 "pl-parser.y" /* yacc.c:1646 */
1928  { set_font_check_sum((yyvsp[0]).yint); }
1929 #line 1930 "pl-parser.c" /* yacc.c:1646 */
1930  break;
1931 
1932  case 84:
1933 #line 356 "pl-parser.y" /* yacc.c:1646 */
1934  { set_font_at((yyvsp[0]).yfix); }
1935 #line 1936 "pl-parser.c" /* yacc.c:1646 */
1936  break;
1937 
1938  case 85:
1939 #line 358 "pl-parser.y" /* yacc.c:1646 */
1940  { set_font_design_size((yyvsp[0]).yfix); }
1941 #line 1942 "pl-parser.c" /* yacc.c:1646 */
1942  break;
1943 
1944  case 89:
1945 #line 370 "pl-parser.y" /* yacc.c:1646 */
1946  { set_select_font((yyvsp[0]).yint); }
1947 #line 1948 "pl-parser.c" /* yacc.c:1646 */
1948  break;
1949 
1950  case 90:
1951 #line 372 "pl-parser.y" /* yacc.c:1646 */
1952  { set_set_char((yyvsp[0]).yint); }
1953 #line 1954 "pl-parser.c" /* yacc.c:1646 */
1954  break;
1955 
1956  case 91:
1957 #line 374 "pl-parser.y" /* yacc.c:1646 */
1958  { set_set_rule((yyvsp[-1]).yfix, (yyvsp[0]).yfix); }
1959 #line 1960 "pl-parser.c" /* yacc.c:1646 */
1960  break;
1961 
1962  case 92:
1963 #line 376 "pl-parser.y" /* yacc.c:1646 */
1964  { set_move((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
1965 #line 1966 "pl-parser.c" /* yacc.c:1646 */
1966  break;
1967 
1968  case 93:
1969 #line 378 "pl-parser.y" /* yacc.c:1646 */
1970  { set_push(); }
1971 #line 1972 "pl-parser.c" /* yacc.c:1646 */
1972  break;
1973 
1974  case 94:
1975 #line 380 "pl-parser.y" /* yacc.c:1646 */
1976  { set_pop(); }
1977 #line 1978 "pl-parser.c" /* yacc.c:1646 */
1978  break;
1979 
1980  case 95:
1981 #line 382 "pl-parser.y" /* yacc.c:1646 */
1982  { set_special((yyvsp[0]).ystring); }
1983 #line 1984 "pl-parser.c" /* yacc.c:1646 */
1984  break;
1985 
1986  case 96:
1987 #line 384 "pl-parser.y" /* yacc.c:1646 */
1988  { set_special_hex((yyvsp[0]).ystring); }
1989 #line 1990 "pl-parser.c" /* yacc.c:1646 */
1990  break;
1991 
1992  case 99:
1993 #line 397 "pl-parser.y" /* yacc.c:1646 */
1994  { init_font_ivalue_entry((yyvsp[0]).yint); }
1995 #line 1996 "pl-parser.c" /* yacc.c:1646 */
1996  break;
1997 
1998  case 104:
1999 #line 410 "pl-parser.y" /* yacc.c:1646 */
2000  { set_font_ivalue_definition((yyvsp[0]).yint); }
2001 #line 2002 "pl-parser.c" /* yacc.c:1646 */
2002  break;
2003 
2004  case 108:
2005 #line 422 "pl-parser.y" /* yacc.c:1646 */
2006  { init_font_mvalue_entry((yyvsp[0]).yint); }
2007 #line 2008 "pl-parser.c" /* yacc.c:1646 */
2008  break;
2009 
2010  case 113:
2011 #line 435 "pl-parser.y" /* yacc.c:1646 */
2012  { set_font_mvalue_definition((yyvsp[0]).yfix); }
2013 #line 2014 "pl-parser.c" /* yacc.c:1646 */
2014  break;
2015 
2016  case 117:
2017 #line 447 "pl-parser.y" /* yacc.c:1646 */
2018  { init_font_fvalue_entry((yyvsp[0]).yint); }
2019 #line 2020 "pl-parser.c" /* yacc.c:1646 */
2020  break;
2021 
2022  case 122:
2023 #line 460 "pl-parser.y" /* yacc.c:1646 */
2024  { set_font_fvalue_definition((yyvsp[0]).yfix); }
2025 #line 2026 "pl-parser.c" /* yacc.c:1646 */
2026  break;
2027 
2028  case 126:
2029 #line 472 "pl-parser.y" /* yacc.c:1646 */
2030  { init_font_penalty_entry((yyvsp[0]).yint); }
2031 #line 2032 "pl-parser.c" /* yacc.c:1646 */
2032  break;
2033 
2034  case 131:
2035 #line 485 "pl-parser.y" /* yacc.c:1646 */
2036  { set_font_penalty_definition((yyvsp[0]).yint); }
2037 #line 2038 "pl-parser.c" /* yacc.c:1646 */
2038  break;
2039 
2040  case 135:
2041 #line 497 "pl-parser.y" /* yacc.c:1646 */
2042  { init_font_rule_entry((yyvsp[0]).yint); }
2043 #line 2044 "pl-parser.c" /* yacc.c:1646 */
2044  break;
2045 
2046  case 140:
2047 #line 510 "pl-parser.y" /* yacc.c:1646 */
2048  { set_font_rule_measure((yyvsp[-1]).yint, (yyvsp[0]).yfix); }
2049 #line 2050 "pl-parser.c" /* yacc.c:1646 */
2050  break;
2051 
2052  case 144:
2053 #line 522 "pl-parser.y" /* yacc.c:1646 */
2054  { init_font_glue_entry((yyvsp[0]).yint); }
2055 #line 2056 "pl-parser.c" /* yacc.c:1646 */
2056  break;
2057 
2058  case 149:
2059 #line 535 "pl-parser.y" /* yacc.c:1646 */
2060  { set_font_glue_type((yyvsp[0]).yint); }
2061 #line 2062 "pl-parser.c" /* yacc.c:1646 */
2062  break;
2063 
2064  case 150:
2065 #line 537 "pl-parser.y" /* yacc.c:1646 */
2066  { set_font_glue_width((yyvsp[0]).yfix); }
2067 #line 2068 "pl-parser.c" /* yacc.c:1646 */
2068  break;
2069 
2070  case 151:
2071 #line 539 "pl-parser.y" /* yacc.c:1646 */
2072  { set_font_glue_character((yyvsp[0]).yint); }
2073 #line 2074 "pl-parser.c" /* yacc.c:1646 */
2074  break;
2075 
2076  case 152:
2077 #line 541 "pl-parser.y" /* yacc.c:1646 */
2078  { set_font_glue_rule((yyvsp[-1]).yint, (yyvsp[0]).yint); }
2079 #line 2080 "pl-parser.c" /* yacc.c:1646 */
2080  break;
2081 
2082  case 153:
2083 #line 543 "pl-parser.y" /* yacc.c:1646 */
2084  { set_font_glue_shrink_stretch((yyvsp[-2]).yint, (yyvsp[-1]).yfix, (yyvsp[0]).yint); }
2085 #line 2086 "pl-parser.c" /* yacc.c:1646 */
2086  break;
2087 
2088 
2089 #line 2090 "pl-parser.c" /* yacc.c:1646 */
2090  default: break;
2091  }
2092  /* User semantic actions sometimes alter yychar, and that requires
2093  that yytoken be updated with the new translation. We take the
2094  approach of translating immediately before every use of yytoken.
2095  One alternative is translating here after every semantic action,
2096  but that translation would be missed if the semantic action invokes
2097  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2098  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2099  incorrect destructor might then be invoked immediately. In the
2100  case of YYERROR or YYBACKUP, subsequent parser actions might lead
2101  to an incorrect destructor call or verbose syntax error message
2102  before the lookahead is translated. */
2103  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2104 
2105  YYPOPSTACK (yylen);
2106  yylen = 0;
2107  YY_STACK_PRINT (yyss, yyssp);
2108 
2109  *++yyvsp = yyval;
2110 
2111  /* Now 'shift' the result of the reduction. Determine what state
2112  that goes to, based on the state we popped back to and the rule
2113  number reduced by. */
2114 
2115  yyn = yyr1[yyn];
2116 
2117  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
2118  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2119  yystate = yytable[yystate];
2120  else
2121  yystate = yydefgoto[yyn - YYNTOKENS];
2122 
2123  goto yynewstate;
2124 
2125 
2126 /*--------------------------------------.
2127 | yyerrlab -- here on detecting error. |
2128 `--------------------------------------*/
2129 yyerrlab:
2130  /* Make sure we have latest lookahead translation. See comments at
2131  user semantic actions for why this is necessary. */
2132  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
2133 
2134  /* If not already recovering from an error, report this error. */
2135  if (!yyerrstatus)
2136  {
2137  ++yynerrs;
2138 #if ! YYERROR_VERBOSE
2139  yyerror (YY_("syntax error"));
2140 #else
2141 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
2142  yyssp, yytoken)
2143  {
2144  char const *yymsgp = YY_("syntax error");
2145  int yysyntax_error_status;
2146  yysyntax_error_status = YYSYNTAX_ERROR;
2147  if (yysyntax_error_status == 0)
2148  yymsgp = yymsg;
2149  else if (yysyntax_error_status == 1)
2150  {
2151  if (yymsg != yymsgbuf)
2152  YYSTACK_FREE (yymsg);
2153  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
2154  if (!yymsg)
2155  {
2156  yymsg = yymsgbuf;
2157  yymsg_alloc = sizeof yymsgbuf;
2158  yysyntax_error_status = 2;
2159  }
2160  else
2161  {
2162  yysyntax_error_status = YYSYNTAX_ERROR;
2163  yymsgp = yymsg;
2164  }
2165  }
2166  yyerror (yymsgp);
2167  if (yysyntax_error_status == 2)
2168  goto yyexhaustedlab;
2169  }
2170 # undef YYSYNTAX_ERROR
2171 #endif
2172  }
2173 
2174 
2175 
2176  if (yyerrstatus == 3)
2177  {
2178  /* If just tried and failed to reuse lookahead token after an
2179  error, discard it. */
2180 
2181  if (yychar <= YYEOF)
2182  {
2183  /* Return failure if at end of input. */
2184  if (yychar == YYEOF)
2185  YYABORT;
2186  }
2187  else
2188  {
2189  yydestruct ("Error: discarding",
2190  yytoken, &yylval);
2191  yychar = YYEMPTY;
2192  }
2193  }
2194 
2195  /* Else will try to reuse lookahead token after shifting the error
2196  token. */
2197  goto yyerrlab1;
2198 
2199 
2200 /*---------------------------------------------------.
2201 | yyerrorlab -- error raised explicitly by YYERROR. |
2202 `---------------------------------------------------*/
2203 yyerrorlab:
2204 
2205  /* Pacify compilers like GCC when the user code never invokes
2206  YYERROR and the label yyerrorlab therefore never appears in user
2207  code. */
2208  if (/*CONSTCOND*/ 0)
2209  goto yyerrorlab;
2210 
2211  /* Do not reclaim the symbols of the rule whose action triggered
2212  this YYERROR. */
2213  YYPOPSTACK (yylen);
2214  yylen = 0;
2215  YY_STACK_PRINT (yyss, yyssp);
2216  yystate = *yyssp;
2217  goto yyerrlab1;
2218 
2219 
2220 /*-------------------------------------------------------------.
2221 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2222 `-------------------------------------------------------------*/
2223 yyerrlab1:
2224  yyerrstatus = 3; /* Each real token shifted decrements this. */
2225 
2226  for (;;)
2227  {
2228  yyn = yypact[yystate];
2229  if (!yypact_value_is_default (yyn))
2230  {
2231  yyn += YYTERROR;
2232  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
2233  {
2234  yyn = yytable[yyn];
2235  if (0 < yyn)
2236  break;
2237  }
2238  }
2239 
2240  /* Pop the current state because it cannot handle the error token. */
2241  if (yyssp == yyss)
2242  YYABORT;
2243 
2244 
2245  yydestruct ("Error: popping",
2246  yystos[yystate], yyvsp);
2247  YYPOPSTACK (1);
2248  yystate = *yyssp;
2249  YY_STACK_PRINT (yyss, yyssp);
2250  }
2251 
2253  *++yyvsp = yylval;
2255 
2256 
2257  /* Shift the error token. */
2258  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
2259 
2260  yystate = yyn;
2261  goto yynewstate;
2262 
2263 
2264 /*-------------------------------------.
2265 | yyacceptlab -- YYACCEPT comes here. |
2266 `-------------------------------------*/
2267 yyacceptlab:
2268  yyresult = 0;
2269  goto yyreturn;
2270 
2271 /*-----------------------------------.
2272 | yyabortlab -- YYABORT comes here. |
2273 `-----------------------------------*/
2274 yyabortlab:
2275  yyresult = 1;
2276  goto yyreturn;
2277 
2278 #if !defined yyoverflow || YYERROR_VERBOSE
2279 /*-------------------------------------------------.
2280 | yyexhaustedlab -- memory exhaustion comes here. |
2281 `-------------------------------------------------*/
2282 yyexhaustedlab:
2283  yyerror (YY_("memory exhausted"));
2284  yyresult = 2;
2285  /* Fall through. */
2286 #endif
2287 
2288 yyreturn:
2289  if (yychar != YYEMPTY)
2290  {
2291  /* Make sure we have latest lookahead translation. See comments at
2292  user semantic actions for why this is necessary. */
2293  yytoken = YYTRANSLATE (yychar);
2294  yydestruct ("Cleanup: discarding lookahead",
2295  yytoken, &yylval);
2296  }
2297  /* Do not reclaim the symbols of the rule whose action triggered
2298  this YYABORT or YYACCEPT. */
2299  YYPOPSTACK (yylen);
2300  YY_STACK_PRINT (yyss, yyssp);
2301  while (yyssp != yyss)
2302  {
2303  yydestruct ("Cleanup: popping",
2304  yystos[*yyssp], yyvsp);
2305  YYPOPSTACK (1);
2306  }
2307 #ifndef yyoverflow
2308  if (yyss != yyssa)
2309  YYSTACK_FREE (yyss);
2310 #endif
2311 #if YYERROR_VERBOSE
2312  if (yymsg != yymsgbuf)
2313  YYSTACK_FREE (yymsg);
2314 #endif
2315  return yyresult;
2316 }
void copy_characters(unsigned c, unsigned copies)
void init_character(unsigned c, char_entry *ready_made)
Definition: char_routines.c:98
void set_next_larger(unsigned larger)
void init_var_character(void)
void set_extensible_piece(unsigned piece, unsigned val)
void set_accent(unsigned kind)
void set_character_measure(int index, int val)
void set_character_rule(unsigned table, unsigned index)
void set_font_fvalue_definition(fix fval)
void set_font_glue_shrink_stretch(unsigned shrink_stretch, fix width, unsigned order)
void init_font_penalty(unsigned tab)
void set_character_mvalue(unsigned table, unsigned index)
void init_font_rule(unsigned tab)
void set_character_fvalue(unsigned table, unsigned index)
void set_character_penalty(unsigned table, unsigned index)
void set_font_mvalue_definition(fix fval)
void init_font_mvalue_entry(unsigned index)
void set_font_glue_width(fix width)
void set_font_glue_rule(unsigned rule_table, unsigned rule_index)
void set_font_glue_character(unsigned c)
void init_font_penalty_entry(unsigned index)
void init_font_mvalue(unsigned tab)
void init_font_glue_entry(unsigned index)
void init_font_rule_entry(unsigned index)
void init_font_fvalue_entry(unsigned index)
void set_character_glue(unsigned table, unsigned index)
void init_font_glue(unsigned tab)
void set_font_ivalue_definition(unsigned val)
void init_font_ivalue_entry(unsigned index)
void set_font_glue_type(unsigned type)
void init_font_ivalue(unsigned tab)
void set_font_rule_measure(unsigned measure, fix fval)
void init_font_fvalue(unsigned tab)
void set_character_ivalue(unsigned table, unsigned index)
void set_font_penalty_definition(unsigned val)
void set_push(void)
void set_set_rule(fix height, fix width)
void set_pop(void)
void set_font_at(fix at)
void set_move(unsigned direction, fix fval)
void init_map_font(int font_number)
Definition: font_routines.c:91
void set_select_font(unsigned f)
void end_map(void)
void set_special_hex(string special_hex_string)
void set_font_check_sum(unsigned cs)
void set_font_design_size(fix ds)
void set_vtitle(string title)
void set_special(string special_string)
void set_set_char(unsigned c)
#define yylex
#define yylloc
#define yydebug
#define yyerror
void set_check_sum(unsigned cs)
void set_coding_scheme(string sval)
void set_design_size(fix ds)
void set_font_dir(unsigned direction)
void set_header_word(unsigned index, unsigned val)
void set_face(unsigned f)
void set_seven_bit_safe_flag(unsigned f)
void set_family(string sval)
void set_ofm_level(unsigned level)
void set_design_units(fix du)
#define NULL
Definition: ftobjs.h:61
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
static const yytype_uint16 yyrline[]
Definition: web2c-parser.c:571
static void yy_symbol_value_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
static void yy_reduce_print(yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule)
static void yy_symbol_print(FILE *yyoutput, int yytype, YYSTYPE const *const yyvaluep)
static const char *const yytname[]
Definition: web2c-parser.c:611
#define YYFPRINTF
void set_c_label_command(unsigned new_class)
void set_label_command(unsigned c)
void set_ligature_command(unsigned lig, unsigned c, unsigned val)
void set_c_penalty_command(unsigned new_class, unsigned pen_index)
void set_c_kerning_command(unsigned new_class, fix fval)
void set_stop_command(void)
void set_kerning_command(unsigned c, fix fval)
void set_boundary_character(unsigned c)
void set_skip_command(unsigned val)
void set_c_glue_command(unsigned new_class, unsigned glue_index)
void set_c_penglue_command(unsigned new_class, unsigned pen_index, unsigned glue_index)
void init_ligkern(void)
#define CHAR_BOUNDARY
Definition: manifests.h:268
void set_param_word(int index, int val)
void init_parameters(void)
static void init_map()
Definition: pbmto4425.c:91
#define LIGTABLE
Definition: pl-parser.c:242
unsigned short int yytype_uint16
Definition: pl-parser.c:349
#define CHARMVALUE
Definition: pl-parser.c:286
#define GLUE
Definition: pl-parser.c:300
#define POP
Definition: pl-parser.c:269
#define LABEL
Definition: pl-parser.c:251
static const yytype_uint8 yyr1[]
Definition: pl-parser.c:900
#define EXTEN
Definition: pl-parser.c:250
#define RULEMEASURE
Definition: pl-parser.c:299
int yynerrs
Definition: pl-parser.c:1372
#define CHARACTER
Definition: pl-parser.c:244
#define FONTIVALUE
Definition: pl-parser.c:273
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: pl-parser.c:431
#define YYMAXDEPTH
Definition: pl-parser.c:1120
#define COMMENT
Definition: pl-parser.c:232
#define YYSTACK_FREE
Definition: pl-parser.c:479
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: pl-parser.c:1101
#define NAMEDPARAMETER
Definition: pl-parser.c:245
#define IVALUE
Definition: pl-parser.c:290
void * malloc(size_t)
#define YY_(Msgid)
Definition: pl-parser.c:381
#define MOVE
Definition: pl-parser.c:267
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: pl-parser.c:432
#define PARAMETER
Definition: pl-parser.c:246
yystype yylval
Definition: pl-parser.c:1370
#define YYUSE(E)
Definition: pl-parser.c:414
#define FVALUE
Definition: pl-parser.c:294
static const yytype_uint8 yytranslate[]
Definition: pl-parser.c:591
#define SPECIALHEX
Definition: pl-parser.c:271
#define YYEOF
Definition: pl-parser.c:945
#define YYABORT
Definition: pl-parser.c:948
#define yypact_value_is_default(Yystate)
Definition: pl-parser.c:709
#define FONTMVALUE
Definition: pl-parser.c:275
#define YYSTACK_BYTES(N)
Definition: pl-parser.c:523
static const yytype_int8 yycheck[]
Definition: pl-parser.c:838
#define GLUERULE
Definition: pl-parser.c:304
#define PUSH
Definition: pl-parser.c:268
#define LEFT
Definition: pl-parser.c:228
#define FAMILY
Definition: pl-parser.c:237
static const yytype_int16 yydefgoto[]
Definition: pl-parser.c:798
#define YY_REDUCE_PRINT(Rule)
Definition: pl-parser.c:1103
#define SETRULE
Definition: pl-parser.c:266
#define CLABEL
Definition: pl-parser.c:279
#define MAP
Definition: pl-parser.c:263
#define FONTPENALTY
Definition: pl-parser.c:276
static const yytype_int16 yypact[]
Definition: pl-parser.c:719
#define VTITLE
Definition: pl-parser.c:256
#define SELECTFONT
Definition: pl-parser.c:264
#define YY_NULLPTR
Definition: pl-parser.c:113
#define OFMLEVEL
Definition: pl-parser.c:308
#define YYFINAL
Definition: pl-parser.c:568
#define SKIP
Definition: pl-parser.c:255
static const yytype_int16 yypgoto[]
Definition: pl-parser.c:787
#define NEXTLARGER
Definition: pl-parser.c:248
#define CHARREPEAT
Definition: pl-parser.c:272
#define SETCHAR
Definition: pl-parser.c:265
#define FONTDSIZE
Definition: pl-parser.c:262
#define YYNTOKENS
Definition: pl-parser.c:573
unsigned char yytype_uint8
Definition: pl-parser.c:337
#define GLUEORDER
Definition: pl-parser.c:307
#define YY_STACK_PRINT(Bottom, Top)
Definition: pl-parser.c:1102
#define FIX
Definition: pl-parser.c:231
#define FVALUEVAL
Definition: pl-parser.c:295
#define YYSIZE_T
Definition: pl-parser.c:365
#define YYSTACK_ALLOC_MAXIMUM
Definition: pl-parser.c:481
#define RIGHT
Definition: pl-parser.c:229
int yyparse(void)
Definition: pl-parser.c:1380
#define SPECIAL
Definition: pl-parser.c:270
#define CHARIVALUE
Definition: pl-parser.c:284
static void yydestruct(const char *yymsg, int yytype, yystype *yyvaluep)
Definition: pl-parser.c:1351
#define MAPFONT
Definition: pl-parser.c:257
#define FACE
Definition: pl-parser.c:238
#define VARCHAR
Definition: pl-parser.c:249
#define CHECKSUM
Definition: pl-parser.c:233
#define FONTRULE
Definition: pl-parser.c:277
#define LIG
Definition: pl-parser.c:252
#define GLUESHRINKSTRETCH
Definition: pl-parser.c:306
int yychar
Definition: pl-parser.c:1367
#define FONTCHECKSUM
Definition: pl-parser.c:260
#define PENALTYVAL
Definition: pl-parser.c:297
static const yytype_uint8 yyr2[]
Definition: pl-parser.c:921
#define YYACCEPT
Definition: pl-parser.c:947
#define DESIGNSIZE
Definition: pl-parser.c:234
#define CHARPENALTY
Definition: pl-parser.c:287
#define CHARFVALUE
Definition: pl-parser.c:285
#define YYTRANSLATE(YYX)
Definition: pl-parser.c:586
#define MVALUE
Definition: pl-parser.c:292
#define SEVENBITSAFEFLAG
Definition: pl-parser.c:239
#define HEADER
Definition: pl-parser.c:240
#define CHARMEASURE
Definition: pl-parser.c:247
#define BOUNDARYCHAR
Definition: pl-parser.c:243
#define FONTDIR
Definition: pl-parser.c:309
#define NUMBER
Definition: pl-parser.c:230
static const yytype_uint8 yystos[]
Definition: pl-parser.c:867
#define FONTFVALUE
Definition: pl-parser.c:274
#define GLUEKIND
Definition: pl-parser.c:303
#define RULE
Definition: pl-parser.c:298
#define DESIGNUNITS
Definition: pl-parser.c:235
#define CHARGLUE
Definition: pl-parser.c:289
#define FONTAREA
Definition: pl-parser.c:259
#define YYTERROR
Definition: pl-parser.c:972
#define IVALUEVAL
Definition: pl-parser.c:291
#define YYPOPSTACK(N)
static const yytype_uint16 yytable[]
Definition: pl-parser.c:811
#define ACCENT
Definition: pl-parser.c:310
#define KRN
Definition: pl-parser.c:253
#define CGLUE
Definition: pl-parser.c:281
#define CHARRULE
Definition: pl-parser.c:288
short int yytype_int16
Definition: pl-parser.c:355
#define STOP
Definition: pl-parser.c:254
#define PENALTY
Definition: pl-parser.c:296
#define YYEMPTY
Definition: pl-parser.c:944
#define YYLAST
Definition: pl-parser.c:570
#define CKRN
Definition: pl-parser.c:280
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: pl-parser.c:534
#define FONTNAME
Definition: pl-parser.c:258
#define YYINITDEPTH
Definition: pl-parser.c:1109
#define GLUETYPE
Definition: pl-parser.c:302
#define FONTDIMEN
Definition: pl-parser.c:241
#define FONTGLUE
Definition: pl-parser.c:278
signed char yytype_int8
Definition: pl-parser.c:343
void free(void *)
#define GLUEWD
Definition: pl-parser.c:301
#define yytable_value_is_error(Yytable_value)
Definition: pl-parser.c:714
#define MVALUEVAL
Definition: pl-parser.c:293
#define CPENALTY
Definition: pl-parser.c:282
#define YYSTACK_ALLOC
Definition: pl-parser.c:478
#define YYDPRINTF(Args)
Definition: pl-parser.c:1100
#define GLUECHAR
Definition: pl-parser.c:305
static const yytype_uint8 yydefact[]
Definition: pl-parser.c:754
#define FONTAT
Definition: pl-parser.c:261
#define CPENGLUE
Definition: pl-parser.c:283
#define CODINGSCHEME
Definition: pl-parser.c:236
yytokentype
Definition: pl-parser.h:47
#define FILE
Definition: t1stdio.h:34
#define set_font_area(f, b)
Definition: texfont.h:250
#define set_font_name(f, b)
Definition: texfont.h:245
Definition: sh.h:1317
yytype_int16 yyss_alloc
Definition: pl-parser.c:514
yystype yyvs_alloc
Definition: pl-parser.c:515
#define YYSTYPE
Definition: parser.h:24
static ptrdiff_t yytnamerr(char *yyres, const char *yystr)
Definition: y.tab.c:5454
#define YYCASE_(N, S)
static ptrdiff_t yystrlen(const char *yystr)
Definition: y.tab.c:5415
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: y.tab.c:5432
static int yysyntax_error(ptrdiff_t *yymsg_alloc, char **yymsg, yy_state_t *yyssp, int yytoken)
Definition: y.tab.c:5505
#define YYSYNTAX_ERROR