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)  

gabc-score-determination-y.c
Go to the documentation of this file.
1 /* A Bison parser, made by GNU Bison 3.7.5. */
2 
3 /* Bison implementation for Yacc-like parsers in C
4 
5  Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
6  Inc.
7 
8  This program is free software: you can redistribute it and/or modify
9  it under the terms of the GNU General Public License as published by
10  the Free Software Foundation, either version 3 of the License, or
11  (at your option) any later version.
12 
13  This program is distributed in the hope that it will be useful,
14  but WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16  GNU General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program. If not, see <http://www.gnu.org/licenses/>. */
20 
21 /* As a special exception, you may create a larger work that contains
22  part or all of the Bison parser skeleton and distribute that work
23  under terms of your choice, so long as that work isn't itself a
24  parser generator using the skeleton or a modified version thereof
25  as a parser skeleton. Alternatively, if you modify or redistribute
26  the parser skeleton itself, you may (at your option) remove this
27  special exception, which will cause the skeleton and the resulting
28  Bison output files to be licensed under the GNU General Public
29  License without this special exception.
30 
31  This special exception was added by the Free Software Foundation in
32  version 2.2 of Bison. */
33 
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35  simplifying the original so-called "semantic" parser. */
36 
37 /* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
38  especially those whose name start with YY_ or yy_. They are
39  private implementation details that can be changed or removed. */
40 
41 /* All symbols defined below should begin with yy or YY, to avoid
42  infringing on user name space. This should be done even for local
43  variables, as they might otherwise be expanded by user macros.
44  There are some unavoidable exceptions within include files to
45  define necessary library symbols; they are noted "INFRINGES ON
46  USER NAME SPACE" below. */
47 
48 /* Identify Bison output, and Bison version. */
49 #define YYBISON 30705
50 
51 /* Bison version string. */
52 #define YYBISON_VERSION "3.7.5"
53 
54 /* Skeleton name. */
55 #define YYSKELETON_NAME "yacc.c"
56 
57 /* Pure parsers. */
58 #define YYPURE 0
59 
60 /* Push parsers. */
61 #define YYPUSH 0
62 
63 /* Pull parsers. */
64 #define YYPULL 1
65 
66 
67 /* Substitute the variable and function names. */
68 #define yyparse gabc_score_determination_parse
69 #define yylex gabc_score_determination_lex
70 #define yyerror gabc_score_determination_error
71 #define yydebug gabc_score_determination_debug
72 #define yynerrs gabc_score_determination_nerrs
73 #define yylval gabc_score_determination_lval
74 #define yychar gabc_score_determination_char
75 #define yylloc gabc_score_determination_lloc
76 
77 /* First part of user prologue. */
78 #line 1 "gabc/gabc-score-determination.y"
79 
80 /*
81  * Gregorio is a program that translates gabc files to GregorioTeX
82  * This file implements the score parser.
83  *
84  * Gregorio score determination from gabc.
85  * Copyright (C) 2006-2021 The Gregorio Project (see CONTRIBUTORS.md)
86  *
87  * This file is part of Gregorio.
88  *
89  * This program is free software: you can redistribute it and/or modify it
90  * under the terms of the GNU General Public License as published by the Free
91  * Software Foundation, either version 3 of the License, or (at your option)
92  * any later version.
93  *
94  * This program is distributed in the hope that it will be useful, but WITHOUT
95  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
96  * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
97  * more details.
98  *
99  * You should have received a copy of the GNU General Public License along with
100  * this program. If not, see <http://www.gnu.org/licenses/>.
101  */
102 
103 /*
104  *
105  * This file is certainly not the most easy to understand, it is a bison file.
106  * See the bison manual on gnu.org for further details.
107  *
108  */
109 
110 #include "config.h"
111 #include <stdio.h>
112 #include <stdlib.h>
113 #include <assert.h>
114 #include "bool.h"
115 #include "struct.h"
116 #include "unicode.h"
117 #include "messages.h"
118 #include "characters.h"
119 #include "support.h"
120 #include "sha1.h"
121 #include "plugins.h"
122 #include "gabc.h"
123 
124 #define YYLLOC_DEFAULT(Current, Rhs, N) \
125  if (N) { \
126  (Current).first_line = YYRHSLOC(Rhs, 1).first_line; \
127  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
128  (Current).first_offset = YYRHSLOC (Rhs, 1).first_offset; \
129  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
130  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
131  (Current).last_offset = YYRHSLOC (Rhs, N).last_offset; \
132  (Current).generate_point_and_click = YYRHSLOC (Rhs, 1).generate_point_and_click; \
133  } else { \
134  (Current).first_line = (Current).last_line = YYRHSLOC (Rhs, 0).last_line; \
135  (Current).first_column = (Current).last_column = YYRHSLOC (Rhs, 0).last_column; \
136  (Current).first_offset = (Current).last_offset = YYRHSLOC (Rhs, 0).last_offset; \
137  (Current).first_offset = (Current).last_offset = YYRHSLOC (Rhs, 0).last_offset; \
138  (Current).generate_point_and_click = YYRHSLOC (Rhs, 0).generate_point_and_click; \
139  }
140 
143 
144 /* workaround for bison issue passing pointer to a "local" variable */
145 #define STYLE_BITS &styles
146 
147 /* forward declaration of the flex/bison process function */
148 static int gabc_score_determination_parse(void);
149 
150 /* uncomment it if you want to have an interactive shell to understand the
151  * details on how bison works for a certain input */
152 /* int gabc_score_determination_debug=1; */
153 
154 /*
155  *
156  * We will need some variables and functions through the entire file, we
157  * declare them there:
158  *
159  */
160 
161 /* the score that we will determine and return */
163 /* an array of elements that we will use for each syllable */
166 /* a table containing the macros to use in gabc file */
167 static char *macros[10];
168 /* other variables that we will have to use */
177 static int number_of_voices;
178 static int voice;
179 /* see comments on text to understand this */
181 /* current_key is... the current key... updated by each notes determination
182  * (for key changes) */
183 static int current_key;
184 static bool got_language;
185 static bool got_staff_lines;
186 static bool started_first_word;
187 static struct sha1_ctx digester;
191 static bool has_protrusion;
192 
193 /* punctum_inclinatum_orientation maintains the running punctum inclinatum
194  * orientation in order to decide if the glyph needs to be cut when a punctum
195  * inclinatum with forced orientation is encountered. This should be set to
196  * the shape of a non-liquescent punctum inclinatum with forced orientation
197  * when one is encountered, be left alone when a non-liquescent punctum
198  * inclinatum with undetermined orientation is encountered, or be reset to
199  * S_PUNCTUM_INCLINATUM_UNDETERMINED otherwise (because such ends any previous
200  * run of punctum inclinatum notes). Based on the assumption that a punctum
201  * inclinatum with forced orientation changes all the punctum inclinatum shapes
202  * with undetermined orientation in the same run of notes before and after it
203  * unless influenced by an earlier punctum inclinatum with forced orientation,
204  * the value of punctum_inclinatum_orientation can be used to determine if a
205  * punctum inclinatum with a forced orientation will have a different
206  * orientation than the punctum inclinatum immediately before it, which would
207  * require a cut of the glyph. */
209 
210 static __inline void check_multiple(const char *name, bool exists) {
211  if (exists) {
212  gregorio_messagef("det_score", VERBOSITY_WARNING, 0,
213  _("several %s definitions found, only the last will be taken "
214  "into consideration"), name);
215  }
216 }
217 
218 static void gabc_score_determination_error(const char *error_str)
219 {
220  gregorio_message(error_str, (const char *) "gabc_score_determination_parse",
221  VERBOSITY_ERROR, 0);
222 }
223 
224 /*
225  * The function that will initialize the variables.
226  */
227 
228 static void initialize_variables(bool point_and_click)
229 {
230  int i;
231  /* build a brand new empty score */
233  /* initialization of the first voice info to an empty voice info */
237  /* other initializations */
238  number_of_voices = 1;
239  voice = 0; /* first (and only) voice */
249  for (i = 0; i < 10; i++) {
250  macros[i] = NULL;
251  }
252  got_language = false;
253  got_staff_lines = false;
254  started_first_word = false;
255  styles = 0;
257  generate_point_and_click = point_and_click;
258  clear_syllable_text = false;
259  has_protrusion = false;
260 }
261 
262 /*
263  * function that frees the variables that need it, for when we have finished to
264  * determine the score
265  */
266 
267 static void free_variables(void)
268 {
269  int i;
270  free(elements);
271  for (i = 0; i < 10; i++) {
272  free(macros[i]);
273  }
274 }
275 
276 /*
277  * Function called when we have reached the end of the definitions, it tries to
278  * make the voice_infos coherent.
279  */
280 static void end_definitions(void)
281 {
282  int i;
283 
285  "can't determine valid infos on the score");
286 
288  sizeof(gregorio_element *));
289  for (i = 0; i < number_of_voices; i++) {
290  elements[i] = NULL;
291  }
292 
293  if (!got_language) {
294  static char latin[] = "Latin";
296  }
297 }
298 
299 /*
300  * Here starts the code for the determinations of the notes. The notes are not
301  * precisely determined here, we separate the text describing the notes of each
302  * voice, and we call determine_elements_from_string to really determine them.
303  */
304 static char position = WORD_BEGINNING;
306 static char *abovelinestext = NULL;
307 
308 /*
309  * Function called each time we find a space, it updates the current position.
310  */
311 static void update_position_with_space(void)
312 {
313  if (position == WORD_MIDDLE) {
314  position = WORD_END;
315  }
316  if (position == WORD_BEGINNING) {
318  }
319 }
320 
321 /*
322  * When we encounter a translation center ending, we call this function that
323  * sets translation_type = TR_WITH_CENTER_BEGINNING on previous syllable with
324  * translation
325  */
328 {
330  while (syllable) {
331  if (syllable->translation_type == TR_WITH_CENTER_END) {
332  gregorio_message("encountering translation centering end but "
333  "cannot find translation centering beginning...",
334  "set_translation_center_beginning", VERBOSITY_ERROR, 0);
336  return;
337  }
338  if (syllable->translation) {
339  syllable->translation_type = TR_WITH_CENTER_BEGINNING;
340  return;
341  }
342  syllable = syllable->previous_syllable;
343  }
344  /* we didn't find any beginning... */
345  gregorio_message("encountering translation centering end but cannot find "
346  "translation centering beginning...",
347  "set_translation_center_beginning", VERBOSITY_ERROR, 0);
349 }
350 
351 static void ready_characters(void)
352 {
353  if (current_character) {
357  && !current_syllable->text)) {
358  started_first_word = true;
359  }
360  }
361 }
362 
363 static void rebuild_score_characters(void)
364 {
365  if (score->first_syllable) {
368  syllable = syllable->next_syllable) {
369  const gregorio_character *t;
370 
371  /* find out if there is a forced center */
373  for (t = syllable->text; t; t = t->next_character) {
374  if (!t->is_character && t->cos.s.style == ST_FORCED_CENTER) {
375  syllable->forced_center = true;
377  break;
378  }
379  }
380 
381  if (syllable == score->first_syllable) {
382  /* leave the first syllable text untouched at this time */
383  continue;
384  }
385 
386  gregorio_rebuild_characters(&(syllable->text), center, false);
387 
388  if (syllable->first_word) {
390  }
391  }
392  }
393 }
394 
395 /*
396  *
397  * The two functions called when lex returns a style, we simply add it. All the
398  * complex things will be done by the function after...
399  *
400  */
401 
402 static void add_style(unsigned char style)
403 {
405 }
406 
407 static void end_style(unsigned char style)
408 {
410 }
411 
412 static __inline void save_text(void)
413 {
414  if (has_protrusion) {
416  }
419 }
420 
421 /* a function called when we see a [, basically, all characters are added to
422  * the translation pointer instead of the text pointer */
423 static void start_translation(unsigned char asked_translation_type)
424 {
426  /* the middle letters of the translation have no sense */
427  /*center_is_determined = CENTER_FULLY_DETERMINED;*/
429  translation_type = asked_translation_type;
430 }
431 
432 static void end_translation(void)
433 {
437 }
438 
439 /*
440  * add_text is the function called when lex returns a char *. In
441  * this function we convert it into grewchar, and then we add the corresponding
442  * gregorio_characters in the list of gregorio_characters.
443  */
444 
445 static void add_text(char *mbcharacters)
446 {
447  if (!current_character) {
448  /* insert open styles, leaving out ELISION on purpose */
449  if (styles & SB_I) {
451  }
452  if (styles & SB_B) {
454  }
455  if (styles & SB_TT) {
456  add_style(ST_TT);
457  }
458  if (styles & SB_SC) {
460  }
461  if (styles & SB_UL) {
463  }
464  if (styles & SB_C) {
466  }
467  }
468  if (current_character) {
470  mbcharacters);
473  } else {
475  }
478  }
479  free(mbcharacters);
480 }
481 
482 static void add_protrusion(char *factor)
483 {
484  if (has_protrusion) {
485  gregorio_message("syllable already has protrusion; pr tag ignored",
486  "det_score", VERBOSITY_WARNING, 0);
487  free(factor);
488  } else {
490  gregorio_message("closing open syllable center before protrusion",
491  "det_score", VERBOSITY_WARNING, 0);
494  }
495 
497  add_text(factor);
500  has_protrusion = true;
501  }
502 }
503 
504 static void add_auto_protrusion(char *protrusion)
505 {
506  if (has_protrusion) {
507  add_text(protrusion);
508  } else {
511  add_text(gregorio_strdup("\\GreProtrusionFactor{"));
512 
513  switch (*protrusion) {
514  case ',':
515  add_text(gregorio_strdup("comma"));
516  break;
517  case ';':
518  add_text(gregorio_strdup("semicolon"));
519  break;
520  case ':':
521  add_text(gregorio_strdup("colon"));
522  break;
523  case '.':
524  add_text(gregorio_strdup("period"));
525  break;
526  default:
527  /* not reachable unless there's a programming error */
528  /* LCOV_EXCL_START */
530  "unsupported protruding punctuation: %c", *protrusion);
531  break;
532  /* LCOV_EXCL_STOP */
533  }
534 
538 
540  add_text(protrusion);
542 
543  has_protrusion = true;
544  }
545 }
546 
547 /*
548  * Function to close a syllable and update the position.
549  */
550 
552 {
553  int i = 0;
555 
556  /* make sure any elisions that are opened are closed within the syllable */
557  for (ch = first_text_character; ch; ch = ch->next_character) {
558  if (!ch->is_character) {
559  switch (ch->cos.s.style) {
560  case ST_ELISION:
561  switch (ch->cos.s.type) {
562  case ST_T_BEGIN:
563  ++i;
564  /* the parser precludes this from falling here */
566  "elisions may not be nested");
567  break;
568 
569  case ST_T_END:
570  --i;
571  /* the parser precludes this from failing here */
573  "encountered elision end with no beginning");
574  break;
575 
576  case ST_T_NOTHING:
577  /* not reachable unless there's a programming error */
578  /* LCOV_EXCL_START */
579  gregorio_fail(close_syllable, "encountered ST_T_NOTHING");
580  break;
581  /* LCOV_EXCL_STOP */
582  }
583  break;
584 
585  case ST_FORCED_CENTER:
586  if (i > 0) {
588  _("forced center may not be within an elision"),
589  "close_syllable", VERBOSITY_ERROR, 0);
590  }
591  break;
592 
593  default:
594  break;
595  }
596  }
597  }
598  /* the parser precludes this from failing here */
600  "encountered elision beginning with no end");
601 
606  if (!score->first_syllable) {
607  /* we rebuild the first syllable if we have to */
609  }
612  }
613  /* we update the position */
614  if (position == WORD_BEGINNING) {
616  }
619 
620  if (started_first_word) {
621  started_first_word = false;
622  }
623  }
633  for (i = 0; i < number_of_voices; i++) {
634  elements[i] = NULL;
635  }
637  clear_syllable_text = false;
638  has_protrusion = false;
639 }
640 
641 void gabc_digest(const void *const buf, const size_t size)
642 {
644 }
645 
646 /*
647  * The "main" function. It is the function that is called when we have to read
648  * a gabc file. It takes a file descriptor, that is to say a file that is
649  * aleady open. It returns a valid gregorio_score
650  */
651 
652 gregorio_score *gabc_read_score(FILE *f_in, bool point_and_click)
653 {
654  /* compute the SHA-1 digest while parsing, for I/O efficiency */
656  /* digest GREGORIO_VERSION to get a different value when the version
657  changes */
659  /* the input file that flex will parse */
661  gregorio_assert(f_in, gabc_read_score, "can't read stream from NULL",
662  return NULL);
663  initialize_variables(point_and_click);
664  /* the flex/bison main call, it will build the score (that we have
665  * initialized) */
669  }
677  free_variables();
678  /* then we check the validity and integrity of the score we have built. */
680  gregorio_message(_("unable to determine a valid score from file"),
681  "gabc_read_score", VERBOSITY_ERROR, 0);
682  }
684  return score;
685 }
686 
687 unsigned char nabc_state = 0;
688 size_t nabc_lines = 0;
689 
690 static void gabc_y_add_notes(char *notes, YYLTYPE loc) {
691  if (nabc_state == 0) {
692  if (!elements[voice]) {
696  } else {
700  gregorio_element *last_element = elements[voice];
701  while (last_element->next) {
702  last_element = last_element->next;
703  }
704  last_element->next = new_elements;
705  new_elements->previous = last_element;
706  current_element = new_elements;
707  }
708  } else {
709  if (!elements[voice]) {
712  }
714  "current_element is null, this shouldn't happen!",
715  return);
716  if (!current_element->nabc) {
718  sizeof (char *));
719  }
722  }
723 }
724 
725 static char *concatenate(char *first, char *const second) {
726  first = (char *)gregorio_realloc(first, strlen(first) + strlen(second) + 1);
727  strcat(first, second);
728  free(second);
729  return first;
730 }
731 
732 #line 733 "gabc/gabc-score-determination-y.c"
733 
734 # ifndef YY_CAST
735 # ifdef __cplusplus
736 # define YY_CAST(Type, Val) static_cast<Type> (Val)
737 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
738 # else
739 # define YY_CAST(Type, Val) ((Type) (Val))
740 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
741 # endif
742 # endif
743 # ifndef YY_NULLPTR
744 # if defined __cplusplus
745 # if 201103L <= __cplusplus
746 # define YY_NULLPTR nullptr
747 # else
748 # define YY_NULLPTR 0
749 # endif
750 # else
751 # define YY_NULLPTR ((void*)0)
752 # endif
753 # endif
754 
756 /* Symbol kind. */
758 {
760  YYSYMBOL_YYEOF = 0, /* "end of file" */
761  YYSYMBOL_YYerror = 1, /* error */
762  YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
763  YYSYMBOL_NAME = 3, /* NAME */
764  YYSYMBOL_AUTHOR = 4, /* AUTHOR */
765  YYSYMBOL_GABC_COPYRIGHT = 5, /* GABC_COPYRIGHT */
766  YYSYMBOL_SCORE_COPYRIGHT = 6, /* SCORE_COPYRIGHT */
767  YYSYMBOL_LANGUAGE = 7, /* LANGUAGE */
768  YYSYMBOL_STAFF_LINES = 8, /* STAFF_LINES */
769  YYSYMBOL_ORISCUS_ORIENTATION = 9, /* ORISCUS_ORIENTATION */
770  YYSYMBOL_DEF_MACRO = 10, /* DEF_MACRO */
771  YYSYMBOL_OTHER_HEADER = 11, /* OTHER_HEADER */
772  YYSYMBOL_ANNOTATION = 12, /* ANNOTATION */
773  YYSYMBOL_MODE = 13, /* MODE */
774  YYSYMBOL_MODE_MODIFIER = 14, /* MODE_MODIFIER */
775  YYSYMBOL_MODE_DIFFERENTIA = 15, /* MODE_DIFFERENTIA */
776  YYSYMBOL_END_OF_DEFINITIONS = 16, /* END_OF_DEFINITIONS */
777  YYSYMBOL_END_OF_FILE = 17, /* END_OF_FILE */
778  YYSYMBOL_COLON = 18, /* COLON */
779  YYSYMBOL_SEMICOLON = 19, /* SEMICOLON */
780  YYSYMBOL_CHARACTERS = 20, /* CHARACTERS */
781  YYSYMBOL_NOTES = 21, /* NOTES */
782  YYSYMBOL_HYPHEN = 22, /* HYPHEN */
783  YYSYMBOL_ATTRIBUTE = 23, /* ATTRIBUTE */
784  YYSYMBOL_OPENING_BRACKET = 24, /* OPENING_BRACKET */
785  YYSYMBOL_CLOSING_BRACKET = 25, /* CLOSING_BRACKET */
786  YYSYMBOL_CLOSING_BRACKET_WITH_SPACE = 26, /* CLOSING_BRACKET_WITH_SPACE */
787  YYSYMBOL_I_BEGIN = 27, /* I_BEGIN */
788  YYSYMBOL_I_END = 28, /* I_END */
789  YYSYMBOL_TT_BEGIN = 29, /* TT_BEGIN */
790  YYSYMBOL_TT_END = 30, /* TT_END */
791  YYSYMBOL_UL_BEGIN = 31, /* UL_BEGIN */
792  YYSYMBOL_UL_END = 32, /* UL_END */
793  YYSYMBOL_C_BEGIN = 33, /* C_BEGIN */
794  YYSYMBOL_C_END = 34, /* C_END */
795  YYSYMBOL_B_BEGIN = 35, /* B_BEGIN */
796  YYSYMBOL_B_END = 36, /* B_END */
797  YYSYMBOL_SC_BEGIN = 37, /* SC_BEGIN */
798  YYSYMBOL_SC_END = 38, /* SC_END */
799  YYSYMBOL_SP_BEGIN = 39, /* SP_BEGIN */
800  YYSYMBOL_SP_END = 40, /* SP_END */
801  YYSYMBOL_VERB_BEGIN = 41, /* VERB_BEGIN */
802  YYSYMBOL_VERB_END = 42, /* VERB_END */
803  YYSYMBOL_CENTER_BEGIN = 43, /* CENTER_BEGIN */
804  YYSYMBOL_CENTER_END = 44, /* CENTER_END */
805  YYSYMBOL_ELISION_BEGIN = 45, /* ELISION_BEGIN */
806  YYSYMBOL_ELISION_END = 46, /* ELISION_END */
807  YYSYMBOL_TRANSLATION_BEGIN = 47, /* TRANSLATION_BEGIN */
808  YYSYMBOL_TRANSLATION_END = 48, /* TRANSLATION_END */
809  YYSYMBOL_TRANSLATION_CENTER_END = 49, /* TRANSLATION_CENTER_END */
810  YYSYMBOL_ALT_BEGIN = 50, /* ALT_BEGIN */
811  YYSYMBOL_ALT_END = 51, /* ALT_END */
812  YYSYMBOL_NLBA_B = 52, /* NLBA_B */
813  YYSYMBOL_NLBA_E = 53, /* NLBA_E */
814  YYSYMBOL_EUOUAE_B = 54, /* EUOUAE_B */
815  YYSYMBOL_EUOUAE_E = 55, /* EUOUAE_E */
816  YYSYMBOL_NABC_CUT = 56, /* NABC_CUT */
817  YYSYMBOL_NABC_LINES = 57, /* NABC_LINES */
818  YYSYMBOL_CLEAR = 58, /* CLEAR */
819  YYSYMBOL_PROTRUSION = 59, /* PROTRUSION */
820  YYSYMBOL_PROTRUSION_VALUE = 60, /* PROTRUSION_VALUE */
821  YYSYMBOL_PROTRUSION_END = 61, /* PROTRUSION_END */
822  YYSYMBOL_PROTRUDING_PUNCTUATION = 62, /* PROTRUDING_PUNCTUATION */
823  YYSYMBOL_YYACCEPT = 63, /* $accept */
824  YYSYMBOL_score = 64, /* score */
825  YYSYMBOL_all_definitions = 65, /* all_definitions */
826  YYSYMBOL_definitions = 66, /* definitions */
827  YYSYMBOL_attribute_value = 67, /* attribute_value */
828  YYSYMBOL_attribute = 68, /* attribute */
829  YYSYMBOL_definition = 69, /* definition */
830  YYSYMBOL_notes = 70, /* notes */
831  YYSYMBOL_note = 71, /* note */
832  YYSYMBOL_closing_bracket_with_space = 72, /* closing_bracket_with_space */
833  YYSYMBOL_style_beginning = 73, /* style_beginning */
834  YYSYMBOL_style_end = 74, /* style_end */
835  YYSYMBOL_special_style_beginning = 75, /* special_style_beginning */
836  YYSYMBOL_special_style_end = 76, /* special_style_end */
837  YYSYMBOL_euouae = 77, /* euouae */
838  YYSYMBOL_linebreak_area = 78, /* linebreak_area */
839  YYSYMBOL_protrusion = 79, /* protrusion */
840  YYSYMBOL_character = 80, /* character */
841  YYSYMBOL_text = 81, /* text */
842  YYSYMBOL_translation_character = 82, /* translation_character */
843  YYSYMBOL_translation_text = 83, /* translation_text */
844  YYSYMBOL_translation_beginning = 84, /* translation_beginning */
845  YYSYMBOL_translation = 85, /* translation */
846  YYSYMBOL_above_line_text = 86, /* above_line_text */
847  YYSYMBOL_syllable_with_notes = 87, /* syllable_with_notes */
848  YYSYMBOL_notes_without_word = 88, /* notes_without_word */
849  YYSYMBOL_syllable = 89, /* syllable */
850  YYSYMBOL_syllables = 90 /* syllables */
851 };
852 typedef enum yysymbol_kind_t yysymbol_kind_t;
853 
854 
855 
856 
857 #ifdef short
858 # undef short
859 #endif
860 
861 /* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
862  <limits.h> and (if available) <stdint.h> are included
863  so that the code can choose integer types of a good width. */
864 
865 #ifndef __PTRDIFF_MAX__
866 # include <limits.h> /* INFRINGES ON USER NAME SPACE */
867 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
868 # include <stdint.h> /* INFRINGES ON USER NAME SPACE */
869 # define YY_STDINT_H
870 # endif
871 #endif
872 
873 /* Narrow types that promote to a signed type and that can represent a
874  signed or unsigned integer of at least N bits. In tables they can
875  save space and decrease cache pressure. Promoting to a signed type
876  helps avoid bugs in integer arithmetic. */
877 
878 #ifdef __INT_LEAST8_MAX__
879 typedef __INT_LEAST8_TYPE__ yytype_int8;
880 #elif defined YY_STDINT_H
881 typedef int_least8_t yytype_int8;
882 #else
883 typedef signed char yytype_int8;
884 #endif
885 
886 #ifdef __INT_LEAST16_MAX__
887 typedef __INT_LEAST16_TYPE__ yytype_int16;
888 #elif defined YY_STDINT_H
890 #else
891 typedef short yytype_int16;
892 #endif
893 
894 /* Work around bug in HP-UX 11.23, which defines these macros
895  incorrectly for preprocessor constants. This workaround can likely
896  be removed in 2023, as HPE has promised support for HP-UX 11.23
897  (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
898  <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
899 #ifdef __hpux
900 # undef UINT_LEAST8_MAX
901 # undef UINT_LEAST16_MAX
902 # define UINT_LEAST8_MAX 255
903 # define UINT_LEAST16_MAX 65535
904 #endif
905 
906 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
907 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
908 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
909  && UINT_LEAST8_MAX <= INT_MAX)
911 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
912 typedef unsigned char yytype_uint8;
913 #else
914 typedef short yytype_uint8;
915 #endif
916 
917 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
918 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
919 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
920  && UINT_LEAST16_MAX <= INT_MAX)
922 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
923 typedef unsigned short yytype_uint16;
924 #else
925 typedef int yytype_uint16;
926 #endif
927 
928 #ifndef YYPTRDIFF_T
929 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
930 # define YYPTRDIFF_T __PTRDIFF_TYPE__
931 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
932 # elif defined PTRDIFF_MAX
933 # ifndef ptrdiff_t
934 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
935 # endif
936 # define YYPTRDIFF_T ptrdiff_t
937 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
938 # else
939 # define YYPTRDIFF_T long
940 # define YYPTRDIFF_MAXIMUM LONG_MAX
941 # endif
942 #endif
943 
944 #ifndef YYSIZE_T
945 # ifdef __SIZE_TYPE__
946 # define YYSIZE_T __SIZE_TYPE__
947 # elif defined size_t
948 # define YYSIZE_T size_t
949 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
950 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
951 # define YYSIZE_T size_t
952 # else
953 # define YYSIZE_T unsigned
954 # endif
955 #endif
956 
957 #define YYSIZE_MAXIMUM \
958  YY_CAST (YYPTRDIFF_T, \
959  (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
960  ? YYPTRDIFF_MAXIMUM \
961  : YY_CAST (YYSIZE_T, -1)))
962 
963 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
964 
965 
966 /* Stored state numbers (used for stacks). */
968 
969 /* State numbers in computations. */
970 typedef int yy_state_fast_t;
971 
972 #ifndef YY_
973 # if defined YYENABLE_NLS && YYENABLE_NLS
974 # if ENABLE_NLS
975 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
976 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
977 # endif
978 # endif
979 # ifndef YY_
980 # define YY_(Msgid) Msgid
981 # endif
982 #endif
983 
984 
985 #ifndef YY_ATTRIBUTE_PURE
986 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
987 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
988 # else
989 # define YY_ATTRIBUTE_PURE
990 # endif
991 #endif
992 
993 #ifndef YY_ATTRIBUTE_UNUSED
994 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
995 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
996 # else
997 # define YY_ATTRIBUTE_UNUSED
998 # endif
999 #endif
1000 
1001 /* Suppress unused-variable warnings by "using" E. */
1002 #if ! defined lint || defined __GNUC__
1003 # define YY_USE(E) ((void) (E))
1004 #else
1005 # define YY_USE(E) /* empty */
1006 #endif
1007 
1008 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
1009 /* Suppress an incorrect diagnostic about yylval being uninitialized. */
1010 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
1011  _Pragma ("GCC diagnostic push") \
1012  _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
1013  _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
1014 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
1015  _Pragma ("GCC diagnostic pop")
1016 #else
1017 # define YY_INITIAL_VALUE(Value) Value
1018 #endif
1019 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1020 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1021 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
1022 #endif
1023 #ifndef YY_INITIAL_VALUE
1024 # define YY_INITIAL_VALUE(Value) /* Nothing. */
1025 #endif
1026 
1027 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
1028 # define YY_IGNORE_USELESS_CAST_BEGIN \
1029  _Pragma ("GCC diagnostic push") \
1030  _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
1031 # define YY_IGNORE_USELESS_CAST_END \
1032  _Pragma ("GCC diagnostic pop")
1033 #endif
1034 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
1035 # define YY_IGNORE_USELESS_CAST_BEGIN
1036 # define YY_IGNORE_USELESS_CAST_END
1037 #endif
1038 
1039 
1040 #define YY_ASSERT(E) ((void) (0 && (E)))
1041 
1042 #if !defined yyoverflow
1043 
1044 /* The parser invokes alloca or malloc; define the necessary symbols. */
1045 
1046 # ifdef YYSTACK_USE_ALLOCA
1047 # if YYSTACK_USE_ALLOCA
1048 # ifdef __GNUC__
1049 # define YYSTACK_ALLOC __builtin_alloca
1050 # elif defined __BUILTIN_VA_ARG_INCR
1051 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
1052 # elif defined _AIX
1053 # define YYSTACK_ALLOC __alloca
1054 # elif defined _MSC_VER
1055 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
1056 # define alloca _alloca
1057 # else
1058 # define YYSTACK_ALLOC alloca
1059 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
1060 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1061  /* Use EXIT_SUCCESS as a witness for stdlib.h. */
1062 # ifndef EXIT_SUCCESS
1063 # define EXIT_SUCCESS 0
1064 # endif
1065 # endif
1066 # endif
1067 # endif
1068 # endif
1069 
1070 # ifdef YYSTACK_ALLOC
1071  /* Pacify GCC's 'empty if-body' warning. */
1072 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
1073 # ifndef YYSTACK_ALLOC_MAXIMUM
1074  /* The OS might guarantee only one guard page at the bottom of the stack,
1075  and a page size can be as small as 4096 bytes. So we cannot safely
1076  invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
1077  to allow for a few compiler-allocated temporary stack slots. */
1078 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
1079 # endif
1080 # else
1081 # define YYSTACK_ALLOC YYMALLOC
1082 # define YYSTACK_FREE YYFREE
1083 # ifndef YYSTACK_ALLOC_MAXIMUM
1084 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
1085 # endif
1086 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
1087  && ! ((defined YYMALLOC || defined malloc) \
1088  && (defined YYFREE || defined free)))
1089 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
1090 # ifndef EXIT_SUCCESS
1091 # define EXIT_SUCCESS 0
1092 # endif
1093 # endif
1094 # ifndef YYMALLOC
1095 # define YYMALLOC malloc
1096 # if ! defined malloc && ! defined EXIT_SUCCESS
1097 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
1098 # endif
1099 # endif
1100 # ifndef YYFREE
1101 # define YYFREE free
1102 # if ! defined free && ! defined EXIT_SUCCESS
1103 void free (void *); /* INFRINGES ON USER NAME SPACE */
1104 # endif
1105 # endif
1106 # endif
1107 #endif /* !defined yyoverflow */
1108 
1109 #if (! defined yyoverflow \
1110  && (! defined __cplusplus \
1111  || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
1112  && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
1113 
1114 /* A type that is properly aligned for any stack member. */
1115 union yyalloc
1116 {
1120 };
1121 
1122 /* The size of the maximum gap between one aligned stack and the next. */
1123 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
1124 
1125 /* The size of an array large to enough to hold all stacks, each with
1126  N elements. */
1127 # define YYSTACK_BYTES(N) \
1128  ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE) \
1129  + YYSIZEOF (YYLTYPE)) \
1130  + 2 * YYSTACK_GAP_MAXIMUM)
1131 
1132 # define YYCOPY_NEEDED 1
1133 
1134 /* Relocate STACK from its old location to the new one. The
1135  local variables YYSIZE and YYSTACKSIZE give the old and new number of
1136  elements in the stack, and YYPTR gives the new location of the
1137  stack. Advance YYPTR to a properly aligned location for the next
1138  stack. */
1139 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
1140  do \
1141  { \
1142  YYPTRDIFF_T yynewbytes; \
1143  YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
1144  Stack = &yyptr->Stack_alloc; \
1145  yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
1146  yyptr += yynewbytes / YYSIZEOF (*yyptr); \
1147  } \
1148  while (0)
1149 
1150 #endif
1151 
1152 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
1153 /* Copy COUNT objects from SRC to DST. The source and destination do
1154  not overlap. */
1155 # ifndef YYCOPY
1156 # if defined __GNUC__ && 1 < __GNUC__
1157 # define YYCOPY(Dst, Src, Count) \
1158  __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
1159 # else
1160 # define YYCOPY(Dst, Src, Count) \
1161  do \
1162  { \
1163  YYPTRDIFF_T yyi; \
1164  for (yyi = 0; yyi < (Count); yyi++) \
1165  (Dst)[yyi] = (Src)[yyi]; \
1166  } \
1167  while (0)
1168 # endif
1169 # endif
1170 #endif /* !YYCOPY_NEEDED */
1171 
1172 /* YYFINAL -- State number of the termination state. */
1173 #define YYFINAL 4
1174 /* YYLAST -- Last index in YYTABLE. */
1175 #define YYLAST 247
1176 
1177 /* YYNTOKENS -- Number of terminals. */
1178 #define YYNTOKENS 63
1179 /* YYNNTS -- Number of nonterminals. */
1180 #define YYNNTS 28
1181 /* YYNRULES -- Number of rules. */
1182 #define YYNRULES 101
1183 /* YYNSTATES -- Number of states. */
1184 #define YYNSTATES 145
1185 
1186 /* YYMAXUTOK -- Last valid token kind. */
1187 #define YYMAXUTOK 317
1188 
1189 
1190 /* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
1191  as returned by yylex, with out-of-bounds checking. */
1192 #define YYTRANSLATE(YYX) \
1193  (0 <= (YYX) && (YYX) <= YYMAXUTOK \
1194  ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
1195  : YYSYMBOL_YYUNDEF)
1196 
1197 /* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
1198  as returned by yylex. */
1199 static const yytype_int8 yytranslate[] =
1200 {
1201  0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1202  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1203  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1204  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1205  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1206  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1207  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1208  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1209  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1210  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1211  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1212  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1213  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1214  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1215  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1216  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1217  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1218  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1219  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1220  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1221  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1222  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1223  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1224  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1225  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1226  2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
1227  5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1228  15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1229  25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1230  35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1231  45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1232  55, 56, 57, 58, 59, 60, 61, 62
1233 };
1234 
1235 #if YYDEBUG
1236  /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
1237 static const yytype_int16 yyrline[] =
1238 {
1239  0, 700, 700, 704, 709, 710, 714, 717, 723, 726,
1240  732, 737, 746, 752, 757, 762, 767, 772, 777, 785,
1241  793, 802, 807, 811, 816, 817, 821, 826, 832, 843,
1242  847, 855, 856, 857, 861, 864, 867, 870, 873, 876,
1243  879, 882, 888, 891, 894, 897, 900, 903, 906, 909,
1244  915, 918, 935, 938, 951, 954, 960, 963, 969, 972,
1245  978, 979, 982, 983, 984, 985, 986, 987, 988, 991,
1246  992, 995, 1001, 1002, 1006, 1009, 1010, 1011, 1014, 1020,
1247  1021, 1025, 1031, 1034, 1037, 1044, 1050, 1054, 1061, 1068,
1248  1073, 1078, 1082, 1089, 1096, 1101, 1109, 1112, 1118, 1119,
1249  1122, 1123
1250 };
1251 #endif
1252 
1253 /** Accessing symbol of state STATE. */
1254 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
1255 
1256 #if YYDEBUG || 0
1257 /* The user-facing name of the symbol whose (internal) number is
1258  YYSYMBOL. No bounds checking. */
1259 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
1260 
1261 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1262  First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1263 static const char *const yytname[] =
1264 {
1265  "\"end of file\"", "error", "\"invalid token\"", "NAME", "AUTHOR",
1266  "GABC_COPYRIGHT", "SCORE_COPYRIGHT", "LANGUAGE", "STAFF_LINES",
1267  "ORISCUS_ORIENTATION", "DEF_MACRO", "OTHER_HEADER", "ANNOTATION", "MODE",
1268  "MODE_MODIFIER", "MODE_DIFFERENTIA", "END_OF_DEFINITIONS", "END_OF_FILE",
1269  "COLON", "SEMICOLON", "CHARACTERS", "NOTES", "HYPHEN", "ATTRIBUTE",
1270  "OPENING_BRACKET", "CLOSING_BRACKET", "CLOSING_BRACKET_WITH_SPACE",
1271  "I_BEGIN", "I_END", "TT_BEGIN", "TT_END", "UL_BEGIN", "UL_END",
1272  "C_BEGIN", "C_END", "B_BEGIN", "B_END", "SC_BEGIN", "SC_END", "SP_BEGIN",
1273  "SP_END", "VERB_BEGIN", "VERB_END", "CENTER_BEGIN", "CENTER_END",
1274  "ELISION_BEGIN", "ELISION_END", "TRANSLATION_BEGIN", "TRANSLATION_END",
1275  "TRANSLATION_CENTER_END", "ALT_BEGIN", "ALT_END", "NLBA_B", "NLBA_E",
1276  "EUOUAE_B", "EUOUAE_E", "NABC_CUT", "NABC_LINES", "CLEAR", "PROTRUSION",
1277  "PROTRUSION_VALUE", "PROTRUSION_END", "PROTRUDING_PUNCTUATION",
1278  "$accept", "score", "all_definitions", "definitions", "attribute_value",
1279  "attribute", "definition", "notes", "note", "closing_bracket_with_space",
1280  "style_beginning", "style_end", "special_style_beginning",
1281  "special_style_end", "euouae", "linebreak_area", "protrusion",
1282  "character", "text", "translation_character", "translation_text",
1283  "translation_beginning", "translation", "above_line_text",
1284  "syllable_with_notes", "notes_without_word", "syllable", "syllables", YY_NULLPTR
1285 };
1286 
1287 static const char *
1288 yysymbol_name (yysymbol_kind_t yysymbol)
1289 {
1290  return yytname[yysymbol];
1291 }
1292 #endif
1293 
1294 #ifdef YYPRINT
1295 /* YYTOKNUM[NUM] -- (External) token number corresponding to the
1296  (internal) symbol number NUM (which must be that of a token). */
1297 static const yytype_int16 yytoknum[] =
1298 {
1299  0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1300  265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1301  275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1302  285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1303  295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1304  305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1305  315, 316, 317
1306 };
1307 #endif
1308 
1309 #define YYPACT_NINF (-85)
1310 
1311 #define yypact_value_is_default(Yyn) \
1312  ((Yyn) == YYPACT_NINF)
1313 
1314 #define YYTABLE_NINF (-1)
1315 
1316 #define yytable_value_is_error(Yyn) \
1317  0
1318 
1319  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1320  STATE-NUM. */
1321 static const yytype_int16 yypact[] =
1322 {
1323  -85, 11, -85, 69, -85, 66, 0, 0, 0, 0,
1324  0, 0, 0, 0, 0, 0, 0, 0, 0, -85,
1325  0, -85, -85, -20, -85, -85, -85, -85, -85, -85,
1326  -85, -85, -85, -85, -85, -85, -85, -85, -85, -85,
1327  -85, -85, -85, -85, -85, -85, -85, 4, -85, -85,
1328  -85, -85, -85, -41, -19, -85, -85, -85, -85, -85,
1329  -85, -85, -85, 107, 148, -4, -85, -85, -85, -85,
1330  -7, -85, -85, -85, -85, -85, -85, -85, -85, -85,
1331  -85, -85, -85, -85, -85, -85, 1, -11, -17, -29,
1332  -85, 9, -2, -85, -1, -85, 13, -85, -85, -85,
1333  -85, -85, -85, -85, 184, -85, -85, -85, -6, -11,
1334  -85, -18, 27, 32, -85, -85, -85, -85, -11, -85,
1335  -85, 26, -11, -85, 28, -85, -85, -85, -11, -85,
1336  -85, -11, 27, -85, -85, -85, -85, -11, -11, -85,
1337  -11, -85, -11, -11, -11
1338 };
1339 
1340  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
1341  Performed when YYTABLE does not specify something else to do. Zero
1342  means the default is an error. */
1343 static const yytype_int8 yydefact[] =
1344 {
1345  4, 0, 100, 0, 1, 2, 0, 0, 0, 0,
1346  0, 0, 0, 0, 0, 0, 0, 0, 0, 3,
1347  0, 5, 61, 70, 24, 34, 42, 35, 43, 36,
1348  44, 37, 45, 38, 46, 39, 47, 41, 49, 40,
1349  48, 51, 53, 50, 52, 81, 84, 0, 56, 57,
1350  54, 55, 68, 59, 71, 62, 63, 64, 65, 67,
1351  66, 69, 72, 0, 0, 0, 60, 98, 99, 101,
1352  0, 11, 21, 13, 14, 12, 18, 22, 10, 23,
1353  20, 15, 16, 17, 19, 24, 0, 96, 0, 0,
1354  24, 0, 70, 24, 71, 73, 0, 74, 77, 82,
1355  78, 75, 76, 79, 0, 24, 9, 6, 0, 87,
1356  24, 0, 29, 31, 25, 30, 85, 58, 89, 24,
1357  24, 0, 86, 24, 0, 24, 83, 80, 97, 8,
1358  7, 92, 26, 28, 27, 33, 32, 94, 88, 24,
1359  90, 24, 91, 93, 95
1360 };
1361 
1362  /* YYPGOTO[NTERM-NUM]. */
1363 static const yytype_int16 yypgoto[] =
1364 {
1365  -85, -85, -85, -85, -85, 227, -85, -84, -85, -60,
1366  -62, -61, -85, -85, -85, -85, -85, -10, -85, -50,
1367  -85, -85, -23, -85, -85, -85, -85, -85
1368 };
1369 
1370  /* YYDEFGOTO[NTERM-NUM]. */
1371 static const yytype_int8 yydefgoto[] =
1372 {
1373  0, 1, 2, 3, 108, 71, 21, 87, 114, 115,
1374  55, 56, 57, 58, 59, 60, 61, 62, 63, 103,
1375  104, 64, 65, 66, 67, 68, 69, 5
1376 };
1377 
1378  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
1379  positive, shift that token. If negative, reduce the rule whose
1380  number is the opposite. If YYTABLE_NINF, syntax error. */
1381 static const yytype_uint8 yytable[] =
1382 {
1383  86, 109, 101, 102, 85, 90, 118, 132, 113, 122,
1384  111, 4, 106, 129, 112, 113, 107, 130, 70, 89,
1385  105, 128, 120, 123, 88, 110, 131, 45, 45, 46,
1386  46, 91, 117, 119, 116, 137, 138, 125, 133, 140,
1387  96, 142, 101, 102, 135, 45, 45, 46, 46, 136,
1388  139, 134, 141, 95, 127, 143, 0, 144, 0, 0,
1389  0, 0, 0, 0, 0, 0, 0, 0, 0, 121,
1390  0, 124, 6, 7, 8, 9, 10, 11, 12, 13,
1391  14, 15, 16, 17, 18, 19, 22, 0, 23, 0,
1392  24, 0, 0, 25, 26, 27, 28, 29, 30, 31,
1393  32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1394  42, 43, 44, 45, 0, 46, 47, 0, 48, 49,
1395  50, 51, 0, 0, 52, 53, 20, 22, 54, 92,
1396  0, 93, 0, 0, 25, 26, 27, 28, 29, 30,
1397  31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1398  41, 42, 43, 44, 45, 0, 46, 47, 0, 48,
1399  49, 50, 51, 0, 0, 52, 53, 0, 97, 94,
1400  98, 0, 0, 0, 0, 25, 26, 27, 28, 29,
1401  30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
1402  40, 0, 0, 0, 0, 0, 99, 0, 0, 0,
1403  0, 0, 0, 0, 97, 0, 98, 0, 0, 0,
1404  100, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1405  34, 35, 36, 37, 38, 39, 40, 0, 0, 0,
1406  0, 0, 126, 0, 72, 73, 74, 75, 76, 77,
1407  78, 79, 80, 81, 82, 83, 100, 84
1408 };
1409 
1410 static const yytype_int16 yycheck[] =
1411 {
1412  23, 85, 64, 64, 24, 24, 90, 25, 26, 93,
1413  21, 0, 19, 19, 25, 26, 23, 23, 18, 60,
1414  24, 105, 24, 24, 20, 24, 110, 47, 47, 49,
1415  49, 54, 61, 24, 51, 119, 120, 24, 56, 123,
1416  63, 125, 104, 104, 17, 47, 47, 49, 49, 17,
1417  24, 111, 24, 63, 104, 139, -1, 141, -1, -1,
1418  -1, -1, -1, -1, -1, -1, -1, -1, -1, 92,
1419  -1, 94, 3, 4, 5, 6, 7, 8, 9, 10,
1420  11, 12, 13, 14, 15, 16, 20, -1, 22, -1,
1421  24, -1, -1, 27, 28, 29, 30, 31, 32, 33,
1422  34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1423  44, 45, 46, 47, -1, 49, 50, -1, 52, 53,
1424  54, 55, -1, -1, 58, 59, 57, 20, 62, 22,
1425  -1, 24, -1, -1, 27, 28, 29, 30, 31, 32,
1426  33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
1427  43, 44, 45, 46, 47, -1, 49, 50, -1, 52,
1428  53, 54, 55, -1, -1, 58, 59, -1, 20, 62,
1429  22, -1, -1, -1, -1, 27, 28, 29, 30, 31,
1430  32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1431  42, -1, -1, -1, -1, -1, 48, -1, -1, -1,
1432  -1, -1, -1, -1, 20, -1, 22, -1, -1, -1,
1433  62, 27, 28, 29, 30, 31, 32, 33, 34, 35,
1434  36, 37, 38, 39, 40, 41, 42, -1, -1, -1,
1435  -1, -1, 48, -1, 7, 8, 9, 10, 11, 12,
1436  13, 14, 15, 16, 17, 18, 62, 20
1437 };
1438 
1439  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1440  symbol of state STATE-NUM. */
1441 static const yytype_int8 yystos[] =
1442 {
1443  0, 64, 65, 66, 0, 90, 3, 4, 5, 6,
1444  7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
1445  57, 69, 20, 22, 24, 27, 28, 29, 30, 31,
1446  32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
1447  42, 43, 44, 45, 46, 47, 49, 50, 52, 53,
1448  54, 55, 58, 59, 62, 73, 74, 75, 76, 77,
1449  78, 79, 80, 81, 84, 85, 86, 87, 88, 89,
1450  18, 68, 68, 68, 68, 68, 68, 68, 68, 68,
1451  68, 68, 68, 68, 68, 24, 85, 70, 20, 60,
1452  24, 85, 22, 24, 62, 80, 85, 20, 22, 48,
1453  62, 73, 74, 82, 83, 24, 19, 23, 67, 70,
1454  24, 21, 25, 26, 71, 72, 51, 61, 70, 24,
1455  24, 85, 70, 24, 85, 24, 48, 82, 70, 19,
1456  23, 70, 25, 56, 72, 17, 17, 70, 70, 24,
1457  70, 24, 70, 70, 70
1458 };
1459 
1460  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1461 static const yytype_int8 yyr1[] =
1462 {
1463  0, 63, 64, 65, 66, 66, 67, 67, 68, 68,
1464  69, 69, 69, 69, 69, 69, 69, 69, 69, 69,
1465  69, 69, 69, 69, 70, 70, 71, 71, 71, 71,
1466  71, 72, 72, 72, 73, 73, 73, 73, 73, 73,
1467  73, 73, 74, 74, 74, 74, 74, 74, 74, 74,
1468  75, 75, 76, 76, 77, 77, 78, 78, 79, 79,
1469  80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
1470  80, 80, 81, 81, 82, 82, 82, 82, 82, 83,
1471  83, 84, 85, 85, 85, 86, 87, 87, 87, 87,
1472  87, 87, 87, 87, 87, 87, 88, 88, 89, 89,
1473  90, 90
1474 };
1475 
1476  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
1477 static const yytype_int8 yyr2[] =
1478 {
1479  0, 2, 2, 2, 0, 2, 1, 2, 3, 2,
1480  2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1481  2, 2, 2, 2, 0, 2, 2, 2, 2, 1,
1482  1, 1, 2, 2, 1, 1, 1, 1, 1, 1,
1483  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1484  1, 1, 1, 1, 1, 1, 1, 1, 3, 1,
1485  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1486  1, 1, 1, 2, 1, 1, 1, 1, 1, 1,
1487  2, 1, 2, 3, 1, 3, 3, 3, 4, 3,
1488  4, 4, 4, 5, 4, 5, 2, 3, 1, 1,
1489  0, 2
1490 };
1491 
1492 
1493 enum { YYENOMEM = -2 };
1494 
1495 #define yyerrok (yyerrstatus = 0)
1496 #define yyclearin (yychar = YYEMPTY)
1497 
1498 #define YYACCEPT goto yyacceptlab
1499 #define YYABORT goto yyabortlab
1500 #define YYERROR goto yyerrorlab
1501 
1502 
1503 #define YYRECOVERING() (!!yyerrstatus)
1504 
1505 #define YYBACKUP(Token, Value) \
1506  do \
1507  if (yychar == YYEMPTY) \
1508  { \
1509  yychar = (Token); \
1510  yylval = (Value); \
1511  YYPOPSTACK (yylen); \
1512  yystate = *yyssp; \
1513  goto yybackup; \
1514  } \
1515  else \
1516  { \
1517  yyerror (YY_("syntax error: cannot back up")); \
1518  YYERROR; \
1519  } \
1520  while (0)
1521 
1522 /* Backward compatibility with an undocumented macro.
1523  Use YYerror or YYUNDEF. */
1524 #define YYERRCODE YYUNDEF
1525 
1526 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1527  If N is 0, then set CURRENT to the empty location which ends
1528  the previous symbol: RHS[0] (always defined). */
1529 
1530 #ifndef YYLLOC_DEFAULT
1531 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1532  do \
1533  if (N) \
1534  { \
1535  (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1536  (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1537  (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1538  (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1539  } \
1540  else \
1541  { \
1542  (Current).first_line = (Current).last_line = \
1543  YYRHSLOC (Rhs, 0).last_line; \
1544  (Current).first_column = (Current).last_column = \
1545  YYRHSLOC (Rhs, 0).last_column; \
1546  } \
1547  while (0)
1548 #endif
1549 
1550 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1551 
1552 
1553 /* Enable debugging if requested. */
1554 #if YYDEBUG
1555 
1556 # ifndef YYFPRINTF
1557 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1558 # define YYFPRINTF fprintf
1559 # endif
1560 
1561 # define YYDPRINTF(Args) \
1562 do { \
1563  if (yydebug) \
1564  YYFPRINTF Args; \
1565 } while (0)
1566 
1567 
1568 /* YY_LOCATION_PRINT -- Print the location on the stream.
1569  This macro was not mandated originally: define only if we know
1570  we won't break user code: when these are the locations we know. */
1571 
1572 # ifndef YY_LOCATION_PRINT
1573 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1574 
1575 /* Print *YYLOCP on YYO. Private, do not rely on its existence. */
1576 
1578 static int
1579 yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
1580 {
1581  int res = 0;
1582  int end_col = 0 != yylocp->last_column ? yylocp->last_column - 1 : 0;
1583  if (0 <= yylocp->first_line)
1584  {
1585  res += YYFPRINTF (yyo, "%d", yylocp->first_line);
1586  if (0 <= yylocp->first_column)
1587  res += YYFPRINTF (yyo, ".%d", yylocp->first_column);
1588  }
1589  if (0 <= yylocp->last_line)
1590  {
1591  if (yylocp->first_line < yylocp->last_line)
1592  {
1593  res += YYFPRINTF (yyo, "-%d", yylocp->last_line);
1594  if (0 <= end_col)
1595  res += YYFPRINTF (yyo, ".%d", end_col);
1596  }
1597  else if (0 <= end_col && yylocp->first_column < end_col)
1598  res += YYFPRINTF (yyo, "-%d", end_col);
1599  }
1600  return res;
1601  }
1602 
1603 # define YY_LOCATION_PRINT(File, Loc) \
1604  yy_location_print_ (File, &(Loc))
1605 
1606 # else
1607 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1608 # endif
1609 # endif /* !defined YY_LOCATION_PRINT */
1610 
1611 
1612 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
1613 do { \
1614  if (yydebug) \
1615  { \
1616  YYFPRINTF (stderr, "%s ", Title); \
1617  yy_symbol_print (stderr, \
1618  Kind, Value, Location); \
1619  YYFPRINTF (stderr, "\n"); \
1620  } \
1621 } while (0)
1622 
1623 
1624 /*-----------------------------------.
1625 | Print this symbol's value on YYO. |
1626 `-----------------------------------*/
1627 
1628 static void
1630  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1631 {
1632  FILE *yyoutput = yyo;
1633  YY_USE (yyoutput);
1634  YY_USE (yylocationp);
1635  if (!yyvaluep)
1636  return;
1637 # ifdef YYPRINT
1638  if (yykind < YYNTOKENS)
1639  YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
1640 # endif
1642  YY_USE (yykind);
1644 }
1645 
1646 
1647 /*---------------------------.
1648 | Print this symbol on YYO. |
1649 `---------------------------*/
1650 
1651 static void
1652 yy_symbol_print (FILE *yyo,
1653  yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp)
1654 {
1655  YYFPRINTF (yyo, "%s %s (",
1656  yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
1657 
1658  YY_LOCATION_PRINT (yyo, *yylocationp);
1659  YYFPRINTF (yyo, ": ");
1660  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp);
1661  YYFPRINTF (yyo, ")");
1662 }
1663 
1664 /*------------------------------------------------------------------.
1665 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1666 | TOP (included). |
1667 `------------------------------------------------------------------*/
1668 
1669 static void
1670 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
1671 {
1672  YYFPRINTF (stderr, "Stack now");
1673  for (; yybottom <= yytop; yybottom++)
1674  {
1675  int yybot = *yybottom;
1676  YYFPRINTF (stderr, " %d", yybot);
1677  }
1678  YYFPRINTF (stderr, "\n");
1679 }
1680 
1681 # define YY_STACK_PRINT(Bottom, Top) \
1682 do { \
1683  if (yydebug) \
1684  yy_stack_print ((Bottom), (Top)); \
1685 } while (0)
1686 
1687 
1688 /*------------------------------------------------.
1689 | Report that the YYRULE is going to be reduced. |
1690 `------------------------------------------------*/
1691 
1692 static void
1693 yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
1694  int yyrule)
1695 {
1696  int yylno = yyrline[yyrule];
1697  int yynrhs = yyr2[yyrule];
1698  int yyi;
1699  YYFPRINTF (stderr, "Reducing stack by rule %d (line %d):\n",
1700  yyrule - 1, yylno);
1701  /* The symbols being reduced. */
1702  for (yyi = 0; yyi < yynrhs; yyi++)
1703  {
1704  YYFPRINTF (stderr, " $%d = ", yyi + 1);
1705  yy_symbol_print (stderr,
1706  YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
1707  &yyvsp[(yyi + 1) - (yynrhs)],
1708  &(yylsp[(yyi + 1) - (yynrhs)]));
1709  YYFPRINTF (stderr, "\n");
1710  }
1711 }
1712 
1713 # define YY_REDUCE_PRINT(Rule) \
1714 do { \
1715  if (yydebug) \
1716  yy_reduce_print (yyssp, yyvsp, yylsp, Rule); \
1717 } while (0)
1718 
1719 /* Nonzero means print parse trace. It is left uninitialized so that
1720  multiple parsers can coexist. */
1721 int yydebug;
1722 #else /* !YYDEBUG */
1723 # define YYDPRINTF(Args) ((void) 0)
1724 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
1725 # define YY_STACK_PRINT(Bottom, Top)
1726 # define YY_REDUCE_PRINT(Rule)
1727 #endif /* !YYDEBUG */
1728 
1729 
1730 /* YYINITDEPTH -- initial size of the parser's stacks. */
1731 #ifndef YYINITDEPTH
1732 # define YYINITDEPTH 200
1733 #endif
1734 
1735 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1736  if the built-in stack extension method is used).
1737 
1738  Do not make this value too large; the results are undefined if
1739  YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1740  evaluated with infinite-precision integer arithmetic. */
1741 
1742 #ifndef YYMAXDEPTH
1743 # define YYMAXDEPTH 10000
1744 #endif
1745 
1746 
1747 
1748 
1749 
1750 
1751 /*-----------------------------------------------.
1752 | Release the memory associated to this symbol. |
1753 `-----------------------------------------------*/
1754 
1755 static void
1756 yydestruct (const char *yymsg,
1757  yysymbol_kind_t yykind, YYSTYPE *yyvaluep, YYLTYPE *yylocationp)
1758 {
1759  YY_USE (yyvaluep);
1760  YY_USE (yylocationp);
1761  if (!yymsg)
1762  yymsg = "Deleting";
1763  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
1764 
1766  YY_USE (yykind);
1768 }
1769 
1770 
1771 /* Lookahead token kind. */
1773 
1774 /* The semantic value of the lookahead symbol. */
1776 /* Location data for the lookahead symbol. */
1778 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
1779  = { 1, 1, 1, 1 }
1780 # endif
1781 ;
1782 /* Number of syntax errors so far. */
1784 
1785 
1786 
1787 
1788 /*----------.
1789 | yyparse. |
1790 `----------*/
1791 
1792 int
1793 yyparse (void)
1794 {
1795  yy_state_fast_t yystate = 0;
1796  /* Number of tokens to shift before error messages enabled. */
1797  int yyerrstatus = 0;
1798 
1799  /* Refer to the stacks through separate pointers, to allow yyoverflow
1800  to reallocate them elsewhere. */
1801 
1802  /* Their size. */
1803  YYPTRDIFF_T yystacksize = YYINITDEPTH;
1804 
1805  /* The state stack: array, bottom, top. */
1806  yy_state_t yyssa[YYINITDEPTH];
1807  yy_state_t *yyss = yyssa;
1808  yy_state_t *yyssp = yyss;
1809 
1810  /* The semantic value stack: array, bottom, top. */
1811  YYSTYPE yyvsa[YYINITDEPTH];
1812  YYSTYPE *yyvs = yyvsa;
1813  YYSTYPE *yyvsp = yyvs;
1814 
1815  /* The location stack: array, bottom, top. */
1816  YYLTYPE yylsa[YYINITDEPTH];
1817  YYLTYPE *yyls = yylsa;
1818  YYLTYPE *yylsp = yyls;
1819 
1820  int yyn;
1821  /* The return value of yyparse. */
1822  int yyresult;
1823  /* Lookahead symbol kind. */
1825  /* The variables used to return semantic value and location from the
1826  action routines. */
1827  YYSTYPE yyval;
1828  YYLTYPE yyloc;
1829 
1830  /* The locations where the error started and ended. */
1831  YYLTYPE yyerror_range[3];
1832 
1833 
1834 
1835 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
1836 
1837  /* The number of symbols on the RHS of the reduced rule.
1838  Keep to zero when no symbol should be popped. */
1839  int yylen = 0;
1840 
1841  YYDPRINTF ((stderr, "Starting parse\n"));
1842 
1843  yychar = YYEMPTY; /* Cause a token to be read. */
1844 
1845 /* User initialization code. */
1846 #line 655 "gabc/gabc-score-determination.y"
1847 {
1848  yylloc.first_line = 1;
1849  yylloc.first_column = 0;
1850  yylloc.first_offset = 0;
1851  yylloc.last_line = 1;
1852  yylloc.last_column = 0;
1853  yylloc.last_offset = 0;
1854  yylloc.generate_point_and_click = generate_point_and_click;
1855 }
1856 
1857 #line 1858 "gabc/gabc-score-determination-y.c"
1858 
1859  yylsp[0] = yylloc;
1860  goto yysetstate;
1861 
1862 
1863 /*------------------------------------------------------------.
1864 | yynewstate -- push a new state, which is found in yystate. |
1865 `------------------------------------------------------------*/
1866 yynewstate:
1867  /* In all cases, when you get here, the value and location stacks
1868  have just been pushed. So pushing a state here evens the stacks. */
1869  yyssp++;
1870 
1871 
1872 /*--------------------------------------------------------------------.
1873 | yysetstate -- set current state (the top of the stack) to yystate. |
1874 `--------------------------------------------------------------------*/
1875 yysetstate:
1876  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1877  YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1879  *yyssp = YY_CAST (yy_state_t, yystate);
1881  YY_STACK_PRINT (yyss, yyssp);
1882 
1883  if (yyss + yystacksize - 1 <= yyssp)
1884 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1885  goto yyexhaustedlab;
1886 #else
1887  {
1888  /* Get the current used size of the three stacks, in elements. */
1889  YYPTRDIFF_T yysize = yyssp - yyss + 1;
1890 
1891 # if defined yyoverflow
1892  {
1893  /* Give user a chance to reallocate the stack. Use copies of
1894  these so that the &'s don't force the real ones into
1895  memory. */
1896  yy_state_t *yyss1 = yyss;
1897  YYSTYPE *yyvs1 = yyvs;
1898  YYLTYPE *yyls1 = yyls;
1899 
1900  /* Each stack pointer address is followed by the size of the
1901  data in use in that stack, in bytes. This used to be a
1902  conditional around just the two extra args, but that might
1903  be undefined if yyoverflow is a macro. */
1904  yyoverflow (YY_("memory exhausted"),
1905  &yyss1, yysize * YYSIZEOF (*yyssp),
1906  &yyvs1, yysize * YYSIZEOF (*yyvsp),
1907  &yyls1, yysize * YYSIZEOF (*yylsp),
1908  &yystacksize);
1909  yyss = yyss1;
1910  yyvs = yyvs1;
1911  yyls = yyls1;
1912  }
1913 # else /* defined YYSTACK_RELOCATE */
1914  /* Extend the stack our own way. */
1915  if (YYMAXDEPTH <= yystacksize)
1916  goto yyexhaustedlab;
1917  yystacksize *= 2;
1918  if (YYMAXDEPTH < yystacksize)
1919  yystacksize = YYMAXDEPTH;
1920 
1921  {
1922  yy_state_t *yyss1 = yyss;
1923  union yyalloc *yyptr =
1924  YY_CAST (union yyalloc *,
1925  YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1926  if (! yyptr)
1927  goto yyexhaustedlab;
1928  YYSTACK_RELOCATE (yyss_alloc, yyss);
1929  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1930  YYSTACK_RELOCATE (yyls_alloc, yyls);
1931 # undef YYSTACK_RELOCATE
1932  if (yyss1 != yyssa)
1933  YYSTACK_FREE (yyss1);
1934  }
1935 # endif
1936 
1937  yyssp = yyss + yysize - 1;
1938  yyvsp = yyvs + yysize - 1;
1939  yylsp = yyls + yysize - 1;
1940 
1942  YYDPRINTF ((stderr, "Stack size increased to %ld\n",
1943  YY_CAST (long, yystacksize)));
1945 
1946  if (yyss + yystacksize - 1 <= yyssp)
1947  YYABORT;
1948  }
1949 #endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1950 
1951  if (yystate == YYFINAL)
1952  YYACCEPT;
1953 
1954  goto yybackup;
1955 
1956 
1957 /*-----------.
1958 | yybackup. |
1959 `-----------*/
1960 yybackup:
1961  /* Do appropriate processing given the current state. Read a
1962  lookahead token if we need one and don't already have one. */
1963 
1964  /* First try to decide what to do without reference to lookahead token. */
1965  yyn = yypact[yystate];
1966  if (yypact_value_is_default (yyn))
1967  goto yydefault;
1968 
1969  /* Not known => get a lookahead token if don't already have one. */
1970 
1971  /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1972  if (yychar == YYEMPTY)
1973  {
1974  YYDPRINTF ((stderr, "Reading a token\n"));
1975  yychar = yylex (STYLE_BITS);
1976  }
1977 
1978  if (yychar <= YYEOF)
1979  {
1980  yychar = YYEOF;
1981  yytoken = YYSYMBOL_YYEOF;
1982  YYDPRINTF ((stderr, "Now at end of input.\n"));
1983  }
1984  else if (yychar == YYerror)
1985  {
1986  /* The scanner already issued an error message, process directly
1987  to error recovery. But do not keep the error token as
1988  lookahead, it is too special and may lead us to an endless
1989  loop in error recovery. */
1990  yychar = YYUNDEF;
1991  yytoken = YYSYMBOL_YYerror;
1992  yyerror_range[1] = yylloc;
1993  goto yyerrlab1;
1994  }
1995  else
1996  {
1997  yytoken = YYTRANSLATE (yychar);
1998  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
1999  }
2000 
2001  /* If the proper action on seeing token YYTOKEN is to reduce or to
2002  detect an error, take that action. */
2003  yyn += yytoken;
2004  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2005  goto yydefault;
2006  yyn = yytable[yyn];
2007  if (yyn <= 0)
2008  {
2009  if (yytable_value_is_error (yyn))
2010  goto yyerrlab;
2011  yyn = -yyn;
2012  goto yyreduce;
2013  }
2014 
2015  /* Count tokens shifted since error; after three, turn off error
2016  status. */
2017  if (yyerrstatus)
2018  yyerrstatus--;
2019 
2020  /* Shift the lookahead token. */
2021  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2022  yystate = yyn;
2024  *++yyvsp = yylval;
2026  *++yylsp = yylloc;
2027 
2028  /* Discard the shifted token. */
2029  yychar = YYEMPTY;
2030  goto yynewstate;
2031 
2032 
2033 /*-----------------------------------------------------------.
2034 | yydefault -- do the default action for the current state. |
2035 `-----------------------------------------------------------*/
2036 yydefault:
2037  yyn = yydefact[yystate];
2038  if (yyn == 0)
2039  goto yyerrlab;
2040  goto yyreduce;
2041 
2042 
2043 /*-----------------------------.
2044 | yyreduce -- do a reduction. |
2045 `-----------------------------*/
2046 yyreduce:
2047  /* yyn is the number of a rule to reduce with. */
2048  yylen = yyr2[yyn];
2049 
2050  /* If YYLEN is nonzero, implement the default value of the action:
2051  '$$ = $1'.
2052 
2053  Otherwise, the following line sets YYVAL to garbage.
2054  This behavior is undocumented and Bison
2055  users should not rely upon it. Assigning to YYVAL
2056  unconditionally makes the parser a bit smaller, and it avoids a
2057  GCC warning that YYVAL may be used uninitialized. */
2058  yyval = yyvsp[1-yylen];
2059 
2060  /* Default location. */
2061  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2062  yyerror_range[1] = yyloc;
2063  YY_REDUCE_PRINT (yyn);
2064  switch (yyn)
2065  {
2066  case 3: /* all_definitions: definitions END_OF_DEFINITIONS */
2067 #line 704 "gabc/gabc-score-determination.y"
2068  {
2069  end_definitions();
2070  }
2071 #line 2072 "gabc/gabc-score-determination-y.c"
2072  break;
2073 
2074  case 6: /* attribute_value: ATTRIBUTE */
2075 #line 714 "gabc/gabc-score-determination.y"
2076  {
2077  yyval.text = yyvsp[0].text;
2078  }
2079 #line 2080 "gabc/gabc-score-determination-y.c"
2080  break;
2081 
2082  case 7: /* attribute_value: attribute_value ATTRIBUTE */
2083 #line 717 "gabc/gabc-score-determination.y"
2084  {
2085  yyval.text = concatenate(yyvsp[-1].text, yyvsp[0].text);
2086  }
2087 #line 2088 "gabc/gabc-score-determination-y.c"
2088  break;
2089 
2090  case 8: /* attribute: COLON attribute_value SEMICOLON */
2091 #line 723 "gabc/gabc-score-determination.y"
2092  {
2093  yyval.text = yyvsp[-1].text;
2094  }
2095 #line 2096 "gabc/gabc-score-determination-y.c"
2096  break;
2097 
2098  case 9: /* attribute: COLON SEMICOLON */
2099 #line 726 "gabc/gabc-score-determination.y"
2100  {
2101  yyval.text = NULL;
2102  }
2103 #line 2104 "gabc/gabc-score-determination-y.c"
2104  break;
2105 
2106  case 10: /* definition: DEF_MACRO attribute */
2107 #line 732 "gabc/gabc-score-determination.y"
2108  {
2109  /* these definitions are not passed through */
2110  free(macros[yyvsp[-1].character - '0']);
2111  macros[yyvsp[-1].character - '0'] = yyvsp[0].text;
2112  }
2113 #line 2114 "gabc/gabc-score-determination-y.c"
2114  break;
2115 
2116  case 11: /* definition: NAME attribute */
2117 #line 737 "gabc/gabc-score-determination.y"
2118  {
2119  if (yyvsp[0].text == NULL) {
2120  gregorio_message("name can't be empty","det_score",
2121  VERBOSITY_WARNING, 0);
2122  }
2123  check_multiple("name", score->name != NULL);
2124  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2125  score->name = yyvsp[0].text;
2126  }
2127 #line 2128 "gabc/gabc-score-determination-y.c"
2128  break;
2129 
2130  case 12: /* definition: LANGUAGE attribute */
2131 #line 746 "gabc/gabc-score-determination.y"
2132  {
2133  check_multiple("language", got_language);
2134  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2136  got_language = true;
2137  }
2138 #line 2139 "gabc/gabc-score-determination-y.c"
2139  break;
2140 
2141  case 13: /* definition: GABC_COPYRIGHT attribute */
2142 #line 752 "gabc/gabc-score-determination.y"
2143  {
2144  check_multiple("gabc-copyright", score->gabc_copyright != NULL);
2145  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2146  score->gabc_copyright = yyvsp[0].text;
2147  }
2148 #line 2149 "gabc/gabc-score-determination-y.c"
2149  break;
2150 
2151  case 14: /* definition: SCORE_COPYRIGHT attribute */
2152 #line 757 "gabc/gabc-score-determination.y"
2153  {
2154  check_multiple("score_copyright", score->score_copyright != NULL);
2155  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2156  score->score_copyright = yyvsp[0].text;
2157  }
2158 #line 2159 "gabc/gabc-score-determination-y.c"
2159  break;
2160 
2161  case 15: /* definition: MODE attribute */
2162 #line 762 "gabc/gabc-score-determination.y"
2163  {
2164  check_multiple("mode", score->mode != 0);
2165  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2166  score->mode = yyvsp[0].text;
2167  }
2168 #line 2169 "gabc/gabc-score-determination-y.c"
2169  break;
2170 
2171  case 16: /* definition: MODE_MODIFIER attribute */
2172 #line 767 "gabc/gabc-score-determination.y"
2173  {
2174  check_multiple("mode-modifier", score->mode_modifier != NULL);
2175  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2176  score->mode_modifier = yyvsp[0].text;
2177  }
2178 #line 2179 "gabc/gabc-score-determination-y.c"
2179  break;
2180 
2181  case 17: /* definition: MODE_DIFFERENTIA attribute */
2182 #line 772 "gabc/gabc-score-determination.y"
2183  {
2184  check_multiple("mode-differentia", score->mode_differentia != NULL);
2185  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2186  score->mode_differentia = yyvsp[0].text;
2187  }
2188 #line 2189 "gabc/gabc-score-determination-y.c"
2189  break;
2190 
2191  case 18: /* definition: STAFF_LINES attribute */
2192 #line 777 "gabc/gabc-score-determination.y"
2193  {
2194  check_multiple("staff-lines", got_staff_lines);
2195  if (yyvsp[0].text) {
2196  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2198  got_staff_lines = true;
2199  }
2200  }
2201 #line 2202 "gabc/gabc-score-determination-y.c"
2202  break;
2203 
2204  case 19: /* definition: NABC_LINES attribute */
2205 #line 785 "gabc/gabc-score-determination.y"
2206  {
2207  check_multiple("nabc lines", score->nabc_lines != 0);
2208  if (yyvsp[0].text) {
2209  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2210  nabc_lines=atoi(yyvsp[0].text);
2212  }
2213  }
2214 #line 2215 "gabc/gabc-score-determination-y.c"
2215  break;
2216 
2217  case 20: /* definition: ANNOTATION attribute */
2218 #line 793 "gabc/gabc-score-determination.y"
2219  {
2220  if (score->annotation [MAX_ANNOTATIONS - 1]) {
2221  gregorio_messagef("det_score", VERBOSITY_WARNING, 0,
2222  _("too many definitions of annotation found, only the "
2223  "first %d will be taken"), MAX_ANNOTATIONS);
2224  }
2225  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2227  }
2228 #line 2229 "gabc/gabc-score-determination-y.c"
2229  break;
2230 
2231  case 21: /* definition: AUTHOR attribute */
2232 #line 802 "gabc/gabc-score-determination.y"
2233  {
2234  check_multiple("author", score->author != NULL);
2235  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2236  score->author = yyvsp[0].text;
2237  }
2238 #line 2239 "gabc/gabc-score-determination-y.c"
2239  break;
2240 
2241  case 22: /* definition: ORISCUS_ORIENTATION attribute */
2242 #line 807 "gabc/gabc-score-determination.y"
2243  {
2244  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2245  score->legacy_oriscus_orientation = (strcmp(yyvsp[0].text, "legacy") == 0);
2246  }
2247 #line 2248 "gabc/gabc-score-determination-y.c"
2248  break;
2249 
2250  case 23: /* definition: OTHER_HEADER attribute */
2251 #line 811 "gabc/gabc-score-determination.y"
2252  {
2253  gregorio_add_score_header(score, yyvsp[-1].text, yyvsp[0].text);
2254  }
2255 #line 2256 "gabc/gabc-score-determination-y.c"
2256  break;
2257 
2258  case 26: /* note: NOTES CLOSING_BRACKET */
2259 #line 821 "gabc/gabc-score-determination.y"
2260  {
2261  gabc_y_add_notes(yyvsp[-1].text, (yylsp[-1]));
2262  free(yyvsp[-1].text);
2263  nabc_state=0;
2264  }
2265 #line 2266 "gabc/gabc-score-determination-y.c"
2266  break;
2267 
2268  case 27: /* note: NOTES closing_bracket_with_space */
2269 #line 826 "gabc/gabc-score-determination.y"
2270  {
2271  gabc_y_add_notes(yyvsp[-1].text, (yylsp[-1]));
2272  free(yyvsp[-1].text);
2273  nabc_state=0;
2275  }
2276 #line 2277 "gabc/gabc-score-determination-y.c"
2277  break;
2278 
2279  case 28: /* note: NOTES NABC_CUT */
2280 #line 832 "gabc/gabc-score-determination.y"
2281  {
2282  if (!nabc_lines) {
2283  gregorio_message(_("You used character \"|\" in gabc without "
2284  "setting \"nabc-lines\" parameter. Please "
2285  "set it in your gabc header."),
2286  "det_score", VERBOSITY_FATAL, 0);
2287  }
2288  gabc_y_add_notes(yyvsp[-1].text, (yylsp[-1]));
2289  free(yyvsp[-1].text);
2290  nabc_state = (nabc_state + 1) % (nabc_lines+1);
2291  }
2292 #line 2293 "gabc/gabc-score-determination-y.c"
2293  break;
2294 
2295  case 29: /* note: CLOSING_BRACKET */
2296 #line 843 "gabc/gabc-score-determination.y"
2297  {
2298  elements[voice]=NULL;
2299  nabc_state=0;
2300  }
2301 #line 2302 "gabc/gabc-score-determination-y.c"
2302  break;
2303 
2304  case 30: /* note: closing_bracket_with_space */
2305 #line 847 "gabc/gabc-score-determination.y"
2306  {
2307  elements[voice]=NULL;
2308  nabc_state=0;
2310  }
2311 #line 2312 "gabc/gabc-score-determination-y.c"
2312  break;
2313 
2314  case 34: /* style_beginning: I_BEGIN */
2315 #line 861 "gabc/gabc-score-determination.y"
2316  {
2318  }
2319 #line 2320 "gabc/gabc-score-determination-y.c"
2320  break;
2321 
2322  case 35: /* style_beginning: TT_BEGIN */
2323 #line 864 "gabc/gabc-score-determination.y"
2324  {
2325  add_style(ST_TT);
2326  }
2327 #line 2328 "gabc/gabc-score-determination-y.c"
2328  break;
2329 
2330  case 36: /* style_beginning: UL_BEGIN */
2331 #line 867 "gabc/gabc-score-determination.y"
2332  {
2334  }
2335 #line 2336 "gabc/gabc-score-determination-y.c"
2336  break;
2337 
2338  case 37: /* style_beginning: C_BEGIN */
2339 #line 870 "gabc/gabc-score-determination.y"
2340  {
2342  }
2343 #line 2344 "gabc/gabc-score-determination-y.c"
2344  break;
2345 
2346  case 38: /* style_beginning: B_BEGIN */
2347 #line 873 "gabc/gabc-score-determination.y"
2348  {
2349  add_style(ST_BOLD);
2350  }
2351 #line 2352 "gabc/gabc-score-determination-y.c"
2352  break;
2353 
2354  case 39: /* style_beginning: SC_BEGIN */
2355 #line 876 "gabc/gabc-score-determination.y"
2356  {
2358  }
2359 #line 2360 "gabc/gabc-score-determination-y.c"
2360  break;
2361 
2362  case 40: /* style_beginning: VERB_BEGIN */
2363 #line 879 "gabc/gabc-score-determination.y"
2364  {
2366  }
2367 #line 2368 "gabc/gabc-score-determination-y.c"
2368  break;
2369 
2370  case 41: /* style_beginning: SP_BEGIN */
2371 #line 882 "gabc/gabc-score-determination.y"
2372  {
2374  }
2375 #line 2376 "gabc/gabc-score-determination-y.c"
2376  break;
2377 
2378  case 42: /* style_end: I_END */
2379 #line 888 "gabc/gabc-score-determination.y"
2380  {
2382  }
2383 #line 2384 "gabc/gabc-score-determination-y.c"
2384  break;
2385 
2386  case 43: /* style_end: TT_END */
2387 #line 891 "gabc/gabc-score-determination.y"
2388  {
2389  end_style(ST_TT);
2390  }
2391 #line 2392 "gabc/gabc-score-determination-y.c"
2392  break;
2393 
2394  case 44: /* style_end: UL_END */
2395 #line 894 "gabc/gabc-score-determination.y"
2396  {
2398  }
2399 #line 2400 "gabc/gabc-score-determination-y.c"
2400  break;
2401 
2402  case 45: /* style_end: C_END */
2403 #line 897 "gabc/gabc-score-determination.y"
2404  {
2406  }
2407 #line 2408 "gabc/gabc-score-determination-y.c"
2408  break;
2409 
2410  case 46: /* style_end: B_END */
2411 #line 900 "gabc/gabc-score-determination.y"
2412  {
2413  end_style(ST_BOLD);
2414  }
2415 #line 2416 "gabc/gabc-score-determination-y.c"
2416  break;
2417 
2418  case 47: /* style_end: SC_END */
2419 #line 903 "gabc/gabc-score-determination.y"
2420  {
2422  }
2423 #line 2424 "gabc/gabc-score-determination-y.c"
2424  break;
2425 
2426  case 48: /* style_end: VERB_END */
2427 #line 906 "gabc/gabc-score-determination.y"
2428  {
2430  }
2431 #line 2432 "gabc/gabc-score-determination-y.c"
2432  break;
2433 
2434  case 49: /* style_end: SP_END */
2435 #line 909 "gabc/gabc-score-determination.y"
2436  {
2438  }
2439 #line 2440 "gabc/gabc-score-determination-y.c"
2440  break;
2441 
2442  case 50: /* special_style_beginning: ELISION_BEGIN */
2443 #line 915 "gabc/gabc-score-determination.y"
2444  {
2446  }
2447 #line 2448 "gabc/gabc-score-determination-y.c"
2448  break;
2449 
2450  case 51: /* special_style_beginning: CENTER_BEGIN */
2451 #line 918 "gabc/gabc-score-determination.y"
2452  {
2453  if (center_is_determined) {
2455  "syllable already has center; ignoring additional center",
2456  "det_score", VERBOSITY_WARNING, 0);
2457  } else if (has_protrusion) {
2459  "center not allowed after protrusion; ignored",
2460  "det_score", VERBOSITY_WARNING, 0);
2461  } else {
2464  }
2465  }
2466 #line 2467 "gabc/gabc-score-determination-y.c"
2467  break;
2468 
2469  case 52: /* special_style_end: ELISION_END */
2470 #line 935 "gabc/gabc-score-determination.y"
2471  {
2473  }
2474 #line 2475 "gabc/gabc-score-determination-y.c"
2475  break;
2476 
2477  case 53: /* special_style_end: CENTER_END */
2478 #line 938 "gabc/gabc-score-determination.y"
2479  {
2483  } else {
2485  "not within a syllable center",
2486  "det_score", VERBOSITY_WARNING, 0);
2487  }
2488  }
2489 #line 2490 "gabc/gabc-score-determination-y.c"
2490  break;
2491 
2492  case 54: /* euouae: EUOUAE_B */
2493 #line 951 "gabc/gabc-score-determination.y"
2494  {
2496  }
2497 #line 2498 "gabc/gabc-score-determination-y.c"
2498  break;
2499 
2500  case 55: /* euouae: EUOUAE_E */
2501 #line 954 "gabc/gabc-score-determination.y"
2502  {
2503  euouae = EUOUAE_END;
2504  }
2505 #line 2506 "gabc/gabc-score-determination-y.c"
2506  break;
2507 
2508  case 56: /* linebreak_area: NLBA_B */
2509 #line 960 "gabc/gabc-score-determination.y"
2510  {
2512  }
2513 #line 2514 "gabc/gabc-score-determination-y.c"
2514  break;
2515 
2516  case 57: /* linebreak_area: NLBA_E */
2517 #line 963 "gabc/gabc-score-determination.y"
2518  {
2520  }
2521 #line 2522 "gabc/gabc-score-determination-y.c"
2522  break;
2523 
2524  case 58: /* protrusion: PROTRUSION PROTRUSION_VALUE PROTRUSION_END */
2525 #line 969 "gabc/gabc-score-determination.y"
2526  {
2527  add_protrusion(yyvsp[-1].text);
2528  }
2529 #line 2530 "gabc/gabc-score-determination-y.c"
2530  break;
2531 
2532  case 59: /* protrusion: PROTRUSION */
2533 #line 972 "gabc/gabc-score-determination.y"
2534  {
2535  add_protrusion(gregorio_strdup("d")); /* d = default */
2536  }
2537 #line 2538 "gabc/gabc-score-determination-y.c"
2538  break;
2539 
2540  case 61: /* character: CHARACTERS */
2541 #line 979 "gabc/gabc-score-determination.y"
2542  {
2543  add_text(yyvsp[0].text);
2544  }
2545 #line 2546 "gabc/gabc-score-determination-y.c"
2546  break;
2547 
2548  case 68: /* character: CLEAR */
2549 #line 988 "gabc/gabc-score-determination.y"
2550  {
2551  clear_syllable_text = true;
2552  }
2553 #line 2554 "gabc/gabc-score-determination-y.c"
2554  break;
2555 
2556  case 70: /* character: HYPHEN */
2557 #line 992 "gabc/gabc-score-determination.y"
2558  {
2559  add_text(gregorio_strdup("-"));
2560  }
2561 #line 2562 "gabc/gabc-score-determination-y.c"
2562  break;
2563 
2564  case 71: /* character: PROTRUDING_PUNCTUATION */
2565 #line 995 "gabc/gabc-score-determination.y"
2566  {
2567  add_text(yyvsp[0].text);
2568  }
2569 #line 2570 "gabc/gabc-score-determination-y.c"
2570  break;
2571 
2572  case 74: /* translation_character: CHARACTERS */
2573 #line 1006 "gabc/gabc-score-determination.y"
2574  {
2575  add_text(yyvsp[0].text);
2576  }
2577 #line 2578 "gabc/gabc-score-determination-y.c"
2578  break;
2579 
2580  case 77: /* translation_character: HYPHEN */
2581 #line 1011 "gabc/gabc-score-determination.y"
2582  {
2583  add_text(gregorio_strdup("-"));
2584  }
2585 #line 2586 "gabc/gabc-score-determination-y.c"
2586  break;
2587 
2588  case 78: /* translation_character: PROTRUDING_PUNCTUATION */
2589 #line 1014 "gabc/gabc-score-determination.y"
2590  {
2591  add_text(yyvsp[0].text);
2592  }
2593 #line 2594 "gabc/gabc-score-determination-y.c"
2594  break;
2595 
2596  case 81: /* translation_beginning: TRANSLATION_BEGIN */
2597 #line 1025 "gabc/gabc-score-determination.y"
2598  {
2600  }
2601 #line 2602 "gabc/gabc-score-determination-y.c"
2602  break;
2603 
2604  case 82: /* translation: translation_beginning TRANSLATION_END */
2605 #line 1031 "gabc/gabc-score-determination.y"
2606  {
2607  end_translation();
2608  }
2609 #line 2610 "gabc/gabc-score-determination-y.c"
2610  break;
2611 
2612  case 83: /* translation: translation_beginning translation_text TRANSLATION_END */
2613 #line 1034 "gabc/gabc-score-determination.y"
2614  {
2615  end_translation();
2616  }
2617 #line 2618 "gabc/gabc-score-determination-y.c"
2618  break;
2619 
2620  case 84: /* translation: TRANSLATION_CENTER_END */
2621 #line 1037 "gabc/gabc-score-determination.y"
2622  {
2624  end_translation();
2625  }
2626 #line 2627 "gabc/gabc-score-determination-y.c"
2627  break;
2628 
2629  case 85: /* above_line_text: ALT_BEGIN CHARACTERS ALT_END */
2630 #line 1044 "gabc/gabc-score-determination.y"
2631  {
2632  abovelinestext = yyvsp[-1].text;
2633  }
2634 #line 2635 "gabc/gabc-score-determination-y.c"
2635  break;
2636 
2637  case 86: /* syllable_with_notes: text OPENING_BRACKET notes */
2638 #line 1050 "gabc/gabc-score-determination.y"
2639  {
2640  save_text();
2641  close_syllable(&(yylsp[-2]));
2642  }
2643 #line 2644 "gabc/gabc-score-determination-y.c"
2644  break;
2645 
2646  case 87: /* syllable_with_notes: HYPHEN OPENING_BRACKET notes */
2647 #line 1054 "gabc/gabc-score-determination.y"
2648  {
2650  add_text(gregorio_strdup("\\GreForceHyphen"));
2652  save_text();
2653  close_syllable(&(yylsp[-2]));
2654  }
2655 #line 2656 "gabc/gabc-score-determination-y.c"
2656  break;
2657 
2658  case 88: /* syllable_with_notes: text HYPHEN OPENING_BRACKET notes */
2659 #line 1061 "gabc/gabc-score-determination.y"
2660  {
2662  add_text(gregorio_strdup("\\GreForceHyphen"));
2664  save_text();
2665  close_syllable(&(yylsp[-3]));
2666  }
2667 #line 2668 "gabc/gabc-score-determination-y.c"
2668  break;
2669 
2670  case 89: /* syllable_with_notes: PROTRUDING_PUNCTUATION OPENING_BRACKET notes */
2671 #line 1068 "gabc/gabc-score-determination.y"
2672  {
2673  add_auto_protrusion(yyvsp[-2].text);
2674  save_text();
2675  close_syllable(&(yylsp[-2]));
2676  }
2677 #line 2678 "gabc/gabc-score-determination-y.c"
2678  break;
2679 
2680  case 90: /* syllable_with_notes: text PROTRUDING_PUNCTUATION OPENING_BRACKET notes */
2681 #line 1073 "gabc/gabc-score-determination.y"
2682  {
2683  add_auto_protrusion(yyvsp[-2].text);
2684  save_text();
2685  close_syllable(&(yylsp[-3]));
2686  }
2687 #line 2688 "gabc/gabc-score-determination-y.c"
2688  break;
2689 
2690  case 91: /* syllable_with_notes: text translation OPENING_BRACKET notes */
2691 #line 1078 "gabc/gabc-score-determination.y"
2692  {
2693  save_text();
2694  close_syllable(&(yylsp[-3]));
2695  }
2696 #line 2697 "gabc/gabc-score-determination-y.c"
2697  break;
2698 
2699  case 92: /* syllable_with_notes: HYPHEN translation OPENING_BRACKET notes */
2700 #line 1082 "gabc/gabc-score-determination.y"
2701  {
2703  add_text(gregorio_strdup("\\GreForceHyphen"));
2705  save_text();
2706  close_syllable(&(yylsp[-3]));
2707  }
2708 #line 2709 "gabc/gabc-score-determination-y.c"
2709  break;
2710 
2711  case 93: /* syllable_with_notes: text HYPHEN translation OPENING_BRACKET notes */
2712 #line 1089 "gabc/gabc-score-determination.y"
2713  {
2715  add_text(gregorio_strdup("\\GreForceHyphen"));
2717  save_text();
2718  close_syllable(&(yylsp[-4]));
2719  }
2720 #line 2721 "gabc/gabc-score-determination-y.c"
2721  break;
2722 
2723  case 94: /* syllable_with_notes: PROTRUDING_PUNCTUATION translation OPENING_BRACKET notes */
2724 #line 1096 "gabc/gabc-score-determination.y"
2725  {
2726  add_auto_protrusion(yyvsp[-3].text);
2727  save_text();
2728  close_syllable(&(yylsp[-3]));
2729  }
2730 #line 2731 "gabc/gabc-score-determination-y.c"
2731  break;
2732 
2733  case 95: /* syllable_with_notes: text PROTRUDING_PUNCTUATION translation OPENING_BRACKET notes */
2734 #line 1101 "gabc/gabc-score-determination.y"
2735  {
2736  add_auto_protrusion(yyvsp[-3].text);
2737  save_text();
2738  close_syllable(&(yylsp[-4]));
2739  }
2740 #line 2741 "gabc/gabc-score-determination-y.c"
2741  break;
2742 
2743  case 96: /* notes_without_word: OPENING_BRACKET notes */
2744 #line 1109 "gabc/gabc-score-determination.y"
2745  {
2747  }
2748 #line 2749 "gabc/gabc-score-determination-y.c"
2749  break;
2750 
2751  case 97: /* notes_without_word: translation OPENING_BRACKET notes */
2752 #line 1112 "gabc/gabc-score-determination.y"
2753  {
2755  }
2756 #line 2757 "gabc/gabc-score-determination-y.c"
2757  break;
2758 
2759 
2760 #line 2761 "gabc/gabc-score-determination-y.c"
2761 
2762  default: break;
2763  }
2764  /* User semantic actions sometimes alter yychar, and that requires
2765  that yytoken be updated with the new translation. We take the
2766  approach of translating immediately before every use of yytoken.
2767  One alternative is translating here after every semantic action,
2768  but that translation would be missed if the semantic action invokes
2769  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2770  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2771  incorrect destructor might then be invoked immediately. In the
2772  case of YYERROR or YYBACKUP, subsequent parser actions might lead
2773  to an incorrect destructor call or verbose syntax error message
2774  before the lookahead is translated. */
2775  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
2776 
2777  YYPOPSTACK (yylen);
2778  yylen = 0;
2779 
2780  *++yyvsp = yyval;
2781  *++yylsp = yyloc;
2782 
2783  /* Now 'shift' the result of the reduction. Determine what state
2784  that goes to, based on the state we popped back to and the rule
2785  number reduced by. */
2786  {
2787  const int yylhs = yyr1[yyn] - YYNTOKENS;
2788  const int yyi = yypgoto[yylhs] + *yyssp;
2789  yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2790  ? yytable[yyi]
2791  : yydefgoto[yylhs]);
2792  }
2793 
2794  goto yynewstate;
2795 
2796 
2797 /*--------------------------------------.
2798 | yyerrlab -- here on detecting error. |
2799 `--------------------------------------*/
2800 yyerrlab:
2801  /* Make sure we have latest lookahead translation. See comments at
2802  user semantic actions for why this is necessary. */
2803  yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
2804  /* If not already recovering from an error, report this error. */
2805  if (!yyerrstatus)
2806  {
2807  ++yynerrs;
2808  yyerror (YY_("syntax error"));
2809  }
2810 
2811  yyerror_range[1] = yylloc;
2812  if (yyerrstatus == 3)
2813  {
2814  /* If just tried and failed to reuse lookahead token after an
2815  error, discard it. */
2816 
2817  if (yychar <= YYEOF)
2818  {
2819  /* Return failure if at end of input. */
2820  if (yychar == YYEOF)
2821  YYABORT;
2822  }
2823  else
2824  {
2825  yydestruct ("Error: discarding",
2826  yytoken, &yylval, &yylloc);
2827  yychar = YYEMPTY;
2828  }
2829  }
2830 
2831  /* Else will try to reuse lookahead token after shifting the error
2832  token. */
2833  goto yyerrlab1;
2834 
2835 
2836 /*---------------------------------------------------.
2837 | yyerrorlab -- error raised explicitly by YYERROR. |
2838 `---------------------------------------------------*/
2839 yyerrorlab:
2840  /* Pacify compilers when the user code never invokes YYERROR and the
2841  label yyerrorlab therefore never appears in user code. */
2842  if (0)
2843  YYERROR;
2844 
2845  /* Do not reclaim the symbols of the rule whose action triggered
2846  this YYERROR. */
2847  YYPOPSTACK (yylen);
2848  yylen = 0;
2849  YY_STACK_PRINT (yyss, yyssp);
2850  yystate = *yyssp;
2851  goto yyerrlab1;
2852 
2853 
2854 /*-------------------------------------------------------------.
2855 | yyerrlab1 -- common code for both syntax error and YYERROR. |
2856 `-------------------------------------------------------------*/
2857 yyerrlab1:
2858  yyerrstatus = 3; /* Each real token shifted decrements this. */
2859 
2860  /* Pop stack until we find a state that shifts the error token. */
2861  for (;;)
2862  {
2863  yyn = yypact[yystate];
2864  if (!yypact_value_is_default (yyn))
2865  {
2866  yyn += YYSYMBOL_YYerror;
2867  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
2868  {
2869  yyn = yytable[yyn];
2870  if (0 < yyn)
2871  break;
2872  }
2873  }
2874 
2875  /* Pop the current state because it cannot handle the error token. */
2876  if (yyssp == yyss)
2877  YYABORT;
2878 
2879  yyerror_range[1] = *yylsp;
2880  yydestruct ("Error: popping",
2881  YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp);
2882  YYPOPSTACK (1);
2883  yystate = *yyssp;
2884  YY_STACK_PRINT (yyss, yyssp);
2885  }
2886 
2888  *++yyvsp = yylval;
2890 
2891  yyerror_range[2] = yylloc;
2892  ++yylsp;
2893  YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
2894 
2895  /* Shift the error token. */
2896  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
2897 
2898  yystate = yyn;
2899  goto yynewstate;
2900 
2901 
2902 /*-------------------------------------.
2903 | yyacceptlab -- YYACCEPT comes here. |
2904 `-------------------------------------*/
2905 yyacceptlab:
2906  yyresult = 0;
2907  goto yyreturn;
2908 
2909 
2910 /*-----------------------------------.
2911 | yyabortlab -- YYABORT comes here. |
2912 `-----------------------------------*/
2913 yyabortlab:
2914  yyresult = 1;
2915  goto yyreturn;
2916 
2917 
2918 #if !defined yyoverflow
2919 /*-------------------------------------------------.
2920 | yyexhaustedlab -- memory exhaustion comes here. |
2921 `-------------------------------------------------*/
2922 yyexhaustedlab:
2923  yyerror (YY_("memory exhausted"));
2924  yyresult = 2;
2925  goto yyreturn;
2926 #endif
2927 
2928 
2929 /*-------------------------------------------------------.
2930 | yyreturn -- parsing is finished, clean up and return. |
2931 `-------------------------------------------------------*/
2932 yyreturn:
2933  if (yychar != YYEMPTY)
2934  {
2935  /* Make sure we have latest lookahead translation. See comments at
2936  user semantic actions for why this is necessary. */
2937  yytoken = YYTRANSLATE (yychar);
2938  yydestruct ("Cleanup: discarding lookahead",
2939  yytoken, &yylval, &yylloc);
2940  }
2941  /* Do not reclaim the symbols of the rule whose action triggered
2942  this YYABORT or YYACCEPT. */
2943  YYPOPSTACK (yylen);
2944  YY_STACK_PRINT (yyss, yyssp);
2945  while (yyssp != yyss)
2946  {
2947  yydestruct ("Cleanup: popping",
2948  YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yylsp);
2949  YYPOPSTACK (1);
2950  }
2951 #ifndef yyoverflow
2952  if (yyss != yyssa)
2953  YYSTACK_FREE (yyss);
2954 #endif
2955 
2956  return yyresult;
2957 }
2958 
#define loc
Definition: aptex-macros.h:65
#define name
#define character
Definition: aptex-macros.h:176
void gregorio_set_first_word(gregorio_character **const character)
Definition: characters.c:1299
void gregorio_set_centering_language(char *const language)
Definition: characters.c:108
void gregorio_rebuild_characters(gregorio_character **const param_character, gregorio_center_determination center_is_determined, bool skip_initial)
Definition: characters.c:841
gregorio_center_determination
Definition: characters.h:43
@ CENTER_HALF_DETERMINED
Definition: characters.h:45
@ CENTER_FULLY_DETERMINED
Definition: characters.h:46
@ CENTER_NOT_DETERMINED
Definition: characters.h:44
FILE * f_in
Definition: devnag.c:355
int strcmp()
Definition: coll.cpp:143
#define _(String)
Definition: ftxerr18.c:64
gregorio_element * gabc_det_elements_from_string(char *const str, int *const current_key, char *macros[10], gregorio_scanner_location *const loc, gregorio_shape *const punctum_inclinatum_orientation, const gregorio_score *const score)
void gabc_det_notes_finish(void)
FILE * gabc_score_determination_in
static void gregorio_set_translation_center_beginning(gregorio_syllable *current_syllable)
static void update_position_with_space(void)
static char * macros[10]
#define yylloc
void * malloc(unsigned)
static gregorio_character * first_translation_character
static gregorio_shape punctum_inclinatum_orientation
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YYMAXDEPTH
static void add_style(unsigned char style)
#define YYSTACK_FREE
static const yytype_int8 yytranslate[]
static bool got_language
@ YYSYMBOL_closing_bracket_with_space
@ YYSYMBOL_special_style_end
@ YYSYMBOL_notes_without_word
@ YYSYMBOL_MODE_MODIFIER
@ YYSYMBOL_PROTRUDING_PUNCTUATION
@ YYSYMBOL_TRANSLATION_END
@ YYSYMBOL_all_definitions
@ YYSYMBOL_GABC_COPYRIGHT
@ YYSYMBOL_ORISCUS_ORIENTATION
@ YYSYMBOL_above_line_text
@ YYSYMBOL_PROTRUSION_END
@ YYSYMBOL_translation_character
@ YYSYMBOL_translation_beginning
@ YYSYMBOL_TRANSLATION_CENTER_END
@ YYSYMBOL_attribute_value
@ YYSYMBOL_PROTRUSION_VALUE
@ YYSYMBOL_END_OF_DEFINITIONS
@ YYSYMBOL_style_beginning
@ YYSYMBOL_ELISION_BEGIN
@ YYSYMBOL_SCORE_COPYRIGHT
@ YYSYMBOL_TRANSLATION_BEGIN
@ YYSYMBOL_translation_text
@ YYSYMBOL_OPENING_BRACKET
@ YYSYMBOL_MODE_DIFFERENTIA
@ YYSYMBOL_special_style_beginning
@ YYSYMBOL_linebreak_area
@ YYSYMBOL_syllable_with_notes
@ YYSYMBOL_CLOSING_BRACKET_WITH_SPACE
@ YYSYMBOL_CLOSING_BRACKET
#define YY_ASSERT(E)
#define YY_(Msgid)
static void add_auto_protrusion(char *protrusion)
static void gabc_y_add_notes(char *notes, gregorio_scanner_location loc)
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
static const yytype_int8 yydefact[]
static gregorio_character * first_text_character
#define YYNSTATES
#define YY_IGNORE_USELESS_CAST_END
short yytype_int16
#define yychar
size_t nabc_lines
#define YYABORT
static gabc_style_bits styles
#define YYSTACK_BYTES(N)
gregorio_score * gabc_read_score(FILE *f_in, bool point_and_click)
yytype_uint8 yy_state_t
static gregorio_syllable * current_syllable
#define YYLLOC_DEFAULT(Current, Rhs, N)
static void free_variables(void)
#define YY_REDUCE_PRINT(Rule)
static void ready_characters(void)
#define YY_CAST(Type, Val)
static __inline void save_text(void)
static void add_protrusion(char *factor)
gregorio_element * current_element
static const yytype_int16 yypact[]
#define yylval
static gregorio_voice_info * current_voice_info
#define yylex
#define YY_NULLPTR
static gregorio_euouae euouae
static gregorio_nlba no_linebreak_area
#define YYFINAL
#define YY_ACCESSING_SYMBOL(State)
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
static int gabc_score_determination_parse(void)
static const yytype_int16 yypgoto[]
static int current_key
static bool generate_point_and_click
static void start_translation(unsigned char asked_translation_type)
#define YYNTOKENS
static bool started_first_word
static void end_style(unsigned char style)
unsigned char yytype_uint8
unsigned char nabc_state
#define YY_STACK_PRINT(Bottom, Top)
#define YYSIZE_T
#define YY_IGNORE_USELESS_CAST_BEGIN
static gregorio_character * suspended_character
static int number_of_voices
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, gabc_score_determination_lval_t *yyvaluep, gregorio_scanner_location *yylocationp)
static const yytype_int8 yyr2[]
static bool has_protrusion
static void rebuild_score_characters(void)
#define YYPTRDIFF_T
static void add_text(char *mbcharacters)
static bool clear_syllable_text
#define yynerrs
static char * abovelinestext
static struct sha1_ctx digester
static void gabc_score_determination_error(const char *error_str)
#define yyparse
static bool got_staff_lines
#define YYACCEPT
#define yytable_value_is_error(Yyn)
static void initialize_variables(bool point_and_click)
static void end_translation(void)
static gregorio_center_determination center_is_determined
#define YYTRANSLATE(YYX)
static const yytype_int8 yystos[]
#define yydebug
#define YY_ATTRIBUTE_UNUSED
static gregorio_character * current_character
static gregorio_tr_centering translation_type
static int voice
static const yytype_int8 yyr1[]
#define STYLE_BITS
static gregorio_score * score
static char * concatenate(char *first, char *const second)
static void end_definitions(void)
#define YYPOPSTACK(N)
static void close_syllable(gregorio_scanner_location *loc)
unsigned short yytype_uint16
static const yytype_int8 yydefgoto[]
void gabc_digest(const void *const buf, const size_t size)
#define YYLAST
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
#define yypact_value_is_default(Yyn)
#define YYINITDEPTH
static __inline void check_multiple(const char *name, bool exists)
static const yytype_uint8 yytable[]
signed char yytype_int8
void free(void *)
#define YYERROR
#define YYSIZEOF(X)
static const yytype_int16 yycheck[]
#define YYSTACK_ALLOC
#define YYDPRINTF(Args)
static gregorio_element ** elements
#define YY_USE(E)
#define yyerror
#define YYerror
#define YYUNDEF
bool gabc_check_score_integrity(gregorio_score *score_to_check)
void gabc_suppress_extra_custos_at_linebreak(gregorio_score *score)
void gabc_determine_punctum_inclinatum_orientation(const gregorio_score *const score)
void gabc_determine_ledger_lines(const gregorio_score *const score)
void gabc_determine_oriscus_orientation(const gregorio_score *const score)
bool gabc_check_infos_integrity(gregorio_score *score_to_check)
void gabc_fix_custos_pitches(gregorio_score *score_to_check)
#define t
Definition: afcover.h:96
void sha1_process_bytes(const void *buffer, size_t len, struct sha1_ctx *ctx)
Definition: sha1.c:126
void * sha1_finish_ctx(struct sha1_ctx *ctx, void *resbuf)
Definition: sha1.c:95
void sha1_init_ctx(struct sha1_ctx *ctx)
Definition: sha1.c:59
void gregorio_fix_initial_keys(gregorio_score *score, gregorio_clef_info default_clef)
Definition: struct.c:1417
void gregorio_add_voice_info(gregorio_voice_info **current_voice_info)
Definition: struct.c:1165
void gregorio_add_syllable(gregorio_syllable **current_syllable, int number_of_voices, gregorio_element *elements[], gregorio_character *first_character, gregorio_character *first_translation_character, gregorio_word_position position, char *abovelinestext, gregorio_tr_centering translation_type, gregorio_nlba no_linebreak_area, gregorio_euouae euouae, const gregorio_scanner_location *const loc, const bool first_word, const bool clear)
Definition: struct.c:1045
void gregorio_add_score_header(gregorio_score *score, char *name, char *value)
Definition: struct.c:1221
void gregorio_end_style(gregorio_character **current_character, grestyle_style style)
Definition: struct.c:1006
void gregorio_set_score_staff_lines(gregorio_score *const score, const char staff_lines)
Definition: struct.c:1202
int gregorio_calculate_new_key(gregorio_clef_info clef)
Definition: struct.c:1258
void gregorio_add_element(gregorio_element **current_element, gregorio_glyph *first_glyph)
Definition: struct.c:870
void gregorio_set_score_annotation(gregorio_score *score, char *annotation)
Definition: struct.c:1185
void gregorio_begin_style(gregorio_character **current_character, grestyle_style style)
Definition: struct.c:990
gregorio_clef_info gregorio_default_clef
Definition: struct.c:58
gregorio_score * gregorio_new_score(void)
Definition: struct.c:1124
void * gregorio_realloc(void *ptr, size_t size)
Definition: support.c:76
void * gregorio_calloc(size_t nmemb, size_t size)
Definition: support.c:71
void * gregorio_malloc(size_t size)
Definition: support.c:66
char * gregorio_strdup(const char *s)
Definition: support.c:81
#define NULL
Definition: ftobjs.h:61
small capitals from c petite p scientific i
Definition: afcover.h:80
Arabic default style
Definition: afstyles.h:94
@ center
Definition: annotate.c:15
int16_t int_least16_t
Definition: stdint.h:95
uint16_t uint_least16_t
Definition: stdint.h:99
int8_t int_least8_t
Definition: stdint.h:94
uint8_t uint_least8_t
Definition: stdint.h:98
float factor
Definition: dimen.c:22
int atoi(const char *)
#define buf
static void yy_stack_print(yytype_int16 *yybottom, yytype_int16 *yytop)
#define YY_LOCATION_PRINT(File, Loc)
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 gregorio_message(const char *string, const char *function_name, gregorio_verbosity verbosity, int line_number)
Definition: messages.c:167
void gregorio_messagef(const char *function_name, gregorio_verbosity verbosity, int line_number, const char *format,...)
Definition: messages.c:98
#define gregorio_assert(TEST, FUNCTION, MESSAGE, ON_FALSE)
Definition: messages.h:66
#define gregorio_fail(FUNCTION, MESSAGE)
Definition: messages.h:84
#define gregorio_assert_only(TEST, FUNCTION, MESSAGE)
Definition: messages.h:61
#define gregorio_fail2(FUNCTION, FORMAT, ARG)
Definition: messages.h:87
@ VERBOSITY_WARNING
Definition: messages.h:42
@ VERBOSITY_FATAL
Definition: messages.h:46
@ VERBOSITY_ERROR
Definition: messages.h:44
#define res(length)
Definition: picttoppm.c:287
#define YYEOF
Definition: pl-parser.c:945
unsigned char yytype_uint8
Definition: pl-parser.c:337
short int yytype_int16
Definition: pl-parser.c:355
#define YYEMPTY
Definition: pl-parser.c:944
signed char yytype_int8
Definition: pl-parser.c:343
static int32_t first
Definition: ppagelist.c:29
static int size
Definition: ppmlabel.c:24
#define syllable()
#define GREGORIO_VERSION
Definition: config.h:33
gregorio_character * gregorio_build_char_list_from_buf(const char *const buf)
Definition: unicode.c:125
gregorio_nlba
Definition: struct.h:370
@ NLBA_END
Definition: struct.h:370
@ NLBA_BEGINNING
Definition: struct.h:370
@ NLBA_NORMAL
Definition: struct.h:370
@ ST_SPECIAL_CHAR
Definition: struct.h:339
@ ST_BOLD
Definition: struct.h:339
@ ST_COLORED
Definition: struct.h:339
@ ST_ITALIC
Definition: struct.h:339
@ ST_UNDERLINED
Definition: struct.h:339
@ ST_FORCED_CENTER
Definition: struct.h:339
@ ST_PROTRUSION_FACTOR
Definition: struct.h:339
@ ST_TT
Definition: struct.h:339
@ ST_VERBATIM
Definition: struct.h:339
@ ST_SMALL_CAPS
Definition: struct.h:339
@ ST_ELISION
Definition: struct.h:339
@ ST_PROTRUSION
Definition: struct.h:339
@ ST_T_END
Definition: struct.h:350
@ ST_T_BEGIN
Definition: struct.h:350
@ ST_T_NOTHING
Definition: struct.h:350
gregorio_tr_centering
Definition: struct.h:360
@ TR_NORMAL
Definition: struct.h:360
@ TR_WITH_CENTER_END
Definition: struct.h:360
@ TR_WITH_CENTER_BEGINNING
Definition: struct.h:360
gregorio_shape
Definition: struct.h:144
@ S_PUNCTUM_INCLINATUM_UNDETERMINED
Definition: struct.h:144
#define MAX_ANNOTATIONS
Definition: struct.h:700
gregorio_euouae
Definition: struct.h:376
@ EUOUAE_END
Definition: struct.h:376
@ EUOUAE_NORMAL
Definition: struct.h:376
@ EUOUAE_BEGINNING
Definition: struct.h:376
static __inline void gregorio_go_to_first_character_c(gregorio_character **character)
Definition: struct.h:929
@ WORD_END
Definition: struct.h:383
@ WORD_ONE_SYLLABLE
Definition: struct.h:383
@ WORD_MIDDLE
Definition: struct.h:383
@ WORD_BEGINNING
Definition: struct.h:383
struct gregorio_character * next_character
Definition: struct.h:647
struct gregorio_character * previous_character
Definition: struct.h:648
size_t nabc_lines
Definition: struct.h:573
char ** nabc
Definition: struct.h:571
struct gregorio_element * next
Definition: struct.h:569
struct gregorio_element * previous
Definition: struct.h:568
size_t nabc_lines
Definition: struct.h:723
char * mode_differentia
Definition: struct.h:717
char * mode
Definition: struct.h:715
char * author
Definition: struct.h:718
char * mode_modifier
Definition: struct.h:716
char * score_copyright
Definition: struct.h:714
unsigned char digest[20]
Definition: struct.h:703
char * gabc_copyright
Definition: struct.h:713
char * annotation[2]
Definition: struct.h:720
struct gregorio_syllable * first_syllable
Definition: struct.h:706
bool legacy_oriscus_orientation
Definition: struct.h:736
struct gregorio_voice_info * first_voice_info
Definition: struct.h:729
char * name
Definition: struct.h:712
unsigned int translation_type
Definition: struct.h:672
struct gregorio_syllable * previous_syllable
Definition: struct.h:662
struct gregorio_character * text
Definition: struct.h:654
Definition: sh2.c:920
Definition: sha1.h:39
Definition: dvips.h:235
#define FILE
Definition: t1stdio.h:34
ch
Definition: t4ht.c:1443
*job_name strlen((char *) job_name) - 4)
second
Definition: tex4ht.c:4115
Definition: sh.h:1317
gabc_score_determination_lval_t yyvs_alloc
yytype_int16 yyss_alloc
Definition: pl-parser.c:514
yystype yyvs_alloc
Definition: pl-parser.c:515