gedcom/gedcom.y

   1 /* Parser for Gedcom.
   2    Copyright (C) 2001, 2002 The Genes Development Team
   3    This file is part of the Gedcom parser library.
   4    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2001.
   5
   6    The Gedcom parser library is free software; you can redistribute it
   7    and/or modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The Gedcom parser library is distributed in the hope that it will be
  12    useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the Gedcom parser library; if not, write to the
  18    Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 /* $Id$ */
  22 /* $Name$ */
  23
  24 /* WARNING: THIS PARSER RELIES HEAVILY ON SOME FEATURES OF BISON.
  25    DON'T TRY TO USE IT WITH YACC, IT WON'T WORK...
  26 */
  27
  28 /* Design of the parser:
  29    ---------------------
  30    In general, a GEDCOM file contains records, each consisting of a line
  31    (which we'll call a section), hierarchically containing other lines
  32    (subsections of the section).
  33
  34    This means that in general we have:
  35
  36      A 'record' is a 'section' (sect) containing 'subsections' (subs)
  37      Each 'subsection' (sub) is again a specific 'section' (sect)
  38
  39    In parser notation, this means:
  40
  41      record : sect
  42
  43      sect   : <some prefix> subs <some suffix>
  44
  45      subs   : <empty> | subs sub
  46
  47      sub    : sect_a | sect_b | ...
  48
  49    This pattern is repeated throughout the parser for the different types of
  50    sections.
  51
  52
  53    Cardinality of the subsections:
  54    -------------------------------
  55    Note that in the above, the order of the subsections is of no importance.
  56    Indeed, this is the case in the GEDCOM grammar.  However, this also makes
  57    it difficult to check whether there are not too many subsections of a
  58    specific type, or whether a mandatory subsection is indeed there.
  59
  60    Suppose there is a section A that can contain 0 or 1 B section and
  61    2 C sections.
  62
  63    This can be expressed in parser notation as follows:
  64
  65      A    : CC | BCC | CBC | CCB
  66
  67    So, cardinality is indeed expressable.  However, as the number of subsection
  68    types and the limits grow bigger (and even theoretically limitless), listing
  69    all possible permutations becomes quickly unfeasible.
  70
  71    Much simpler is to say:
  72
  73      A    : subs
  74      subs : <empty> | subs sub
  75      sub  : B | C
  76
  77    and then check the cardinality in the semantic actions, which is the
  78    solution chosen in the parser below, using the following macros:
  79
  80     - OPEN(<parent>)
  81          Make a new context for the <parent> tag to count child tags in
  82
  83     - OCCUR2(<child>, <min>, <max>)
  84          Express that the <child> tag should occur at least <min> times and
  85          at most <max> tags within its parent
  86
  87          What this actually does is the following.  It increments the counter
  88          for that tag and then checks whether the maximum is exceeded.  If so,
  89          then a parser error is produced.  The minimum is not actually checked
  90          by this macro, but it makes the statements more declarative.
  91
  92     - OCCUR1(<child>, <min>)
  93          Express that the <child> tag should occur at least <min> times within
  94          its parent (no upper limit)
  95
  96          Actually, this only increments the counter for the tag, but it looks
  97          very like the previous macro.
  98
  99          If the minimum is 0, it is not necessary to express this constraint.
 100
 101     - CHECKn(<child1>, ..., <childn>)
 102          This closes the context for the parent tag and checks whether the
 103          given <child> tags did effectively occur within the parent (i.e.
 104          these are the tags that were mandatory).
 105
 106          Since the <min> values above are always 0 or 1 in GEDCOM, this is
 107          sufficient.  All sub-tags that declare a minimum of 1 in the OCCUR
 108          macros should be listed in this macro here.
 109
 110          The macros CHECK0 to CHECK4 are defined like this (the first one
 111          has no arguments and is only used to close the parent context; note
 112          that this is necessary for correct functioning).
 113
 114    Example of usage:
 115
 116      Only sections that have subsections need to use these macros.  This can
 117      be done like this (the OPEN and CHECK macros are used as mid-rule
 118      actions around the subsections):
 119
 120        head_sect : OPEN DELIM TAG_HEAD
 121                    { OPEN(HEAD) }
 122                    head_subs
 123                    { CHECK1(SOUR) }
 124                    CLOSE { <semantic actions> }
 125
 126        head_subs : <empty>
 127                  | head_subs head_sub
 128                  ;
 129
 130        head_sub  : head_sour_sect  { OCCUR2(SOUR, 1, 1) }
 131                  | head_dest_sect  { OCCUR2(DEST, 0, 1) }
 132                  | head_date_sect  { OCCUR2(DATE, 0, 1) }
 133                  ;
 134 */
 135
 136 /* General notes:
 137
 138    - The syntax analysis doesn't handle the contents of the line values;
 139      this is done in the semantic analysis.
 140
 141  */
 142
 143 %{
 144 #include "gedcom_internal.h"
 145 #include "multilex.h"
 146 #include "encoding.h"
 147 #include "interface.h"
 148 #include "date.h"
 149 #include "age.h"
 150 #include "xref.h"
 151 #include "compat.h"
 152 #include "buffer.h"
 153
 154 int  count_level    = 0;
 155 int  fail           = 0;
 156 int  gedcom_high_level_debug = 0;
 157 Gedcom_err_mech error_mechanism = IMMED_FAIL;
 158 Gedcom_val_struct val1;
 159 Gedcom_val_struct val2;
 160
 161 void cleanup_line_item_buffer();
 162 struct safe_buffer line_item_buffer = { NULL, 0, NULL, 0,
 163                                         cleanup_line_item_buffer };
 164
 165 void cleanup_concat_buffer();
 166 struct safe_buffer concat_buffer = { NULL, 0, NULL, 0, cleanup_concat_buffer };
 167
 168 void cleanup_usertag_buffer();
 169 struct safe_buffer usertag_buffer = { NULL, 0, NULL, 0,
 170                                       cleanup_usertag_buffer};
 171
 172 /* These are defined at the bottom of the file */
 173 void push_countarray(int level);
 174 void set_parenttag(const char* tag);
 175 char* get_parenttag(int offset);
 176 void set_parentctxt(Gedcom_ctxt ctxt);
 177 Gedcom_ctxt get_parentctxt(int offset);
 178 void pop_countarray();
 179 int  count_tag(int tag);
 180 int  check_occurrence(int tag);
 181 void clean_up();
 182
 183 #define HANDLE_ERROR                                                          \
 184      { if (error_mechanism == IMMED_FAIL) {                                   \
 185          clean_up(); YYABORT;                                                 \
 186        }                                                                      \
 187        else if (error_mechanism == DEFER_FAIL) {                              \
 188          yyerrok; fail = 1;                                                   \
 189        }                                                                      \
 190        else if (error_mechanism == IGNORE_ERRORS) {                           \
 191          yyerrok;                                                             \
 192        }                                                                      \
 193      }
 194 #define START1(PARENTTAG)                                                     \
 195      { set_parenttag(#PARENTTAG);                                             \
 196      }
 197 #define START2(LEVEL,PARENTCTXT)                                              \
 198      { set_parentctxt(PARENTCTXT);                                            \
 199        ++count_level;                                                         \
 200        push_countarray(LEVEL);                                                \
 201      }
 202 #define START(PARENTTAG,LEVEL,PARENTCTXT)                                     \
 203      { START1(PARENTTAG);                                                     \
 204        START2(LEVEL,PARENTCTXT);                                              \
 205      }
 206 #define PARENT                                                                \
 207      get_parentctxt(0)
 208 #define GRANDPARENT(OFF)                                                      \
 209      get_parentctxt(OFF)
 210 #define CHK(TAG)                                                              \
 211      { if (!check_occurrence(TAG_##TAG)) {                                    \
 212          char* parenttag = get_parenttag(0);                                  \
 213          gedcom_error(_("The tag '%s' is mandatory within '%s', but missing"),\
 214                       #TAG, parenttag);                                       \
 215          HANDLE_ERROR;                                                        \
 216        }                                                                      \
 217      }
 218 #define CHK_COND(TAG)                                                         \
 219      check_occurrence(TAG_##TAG)
 220 #define POP                                                                   \
 221      { pop_countarray();                                                      \
 222        --count_level;                                                         \
 223      }
 224 #define CHECK0 POP;
 225 #define CHECK1(TAG1) { CHK(TAG1); POP; }
 226 #define CHECK2(TAG1,TAG2)                                                     \
 227      { CHK(TAG1); CHK(TAG2); POP; }
 228 #define CHECK3(TAG1,TAG2,TAG3)                                                \
 229      { CHK(TAG1); CHK(TAG2); CHK(TAG3); POP; }
 230 #define CHECK4(TAG1,TAG2,TAG3,TAG4)                                           \
 231      { CHK(TAG1); CHK(TAG2); CHK(TAG3); CHK(TAG4); POP; }
 232 #define OCCUR1(CHILDTAG, MIN) { count_tag(TAG_##CHILDTAG); }
 233 #define OCCUR2(CHILDTAG, MIN, MAX)                                            \
 234      { int num = count_tag(TAG_##CHILDTAG);                                   \
 235        if (num > MAX) {                                                       \
 236          char* parenttag = get_parenttag(0);                                  \
 237          gedcom_error(_("The tag '%s' can maximally occur %d time(s) within '%s'"),                                                                          \
 238                       #CHILDTAG, MAX, parenttag);                             \
 239          HANDLE_ERROR;                                                        \
 240        }                                                                      \
 241      }
 242 #define INVALID_TAG(CHILDTAG)                                                 \
 243      { char* parenttag = get_parenttag(0);                                    \
 244        gedcom_error(_("The tag '%s' is not a valid tag within '%s'"),         \
 245                     CHILDTAG, parenttag);                                     \
 246        HANDLE_ERROR;                                                          \
 247      }
 248 #define INVALID_TOP_TAG(CHILDTAG)                                             \
 249      { gedcom_error(_("The tag '%s' is not a valid top-level tag"),           \
 250                     CHILDTAG); \
 251        HANDLE_ERROR; \
 252      }
 253
 254 %}
 255
 256 %union {
 257   int  number;
 258   char *string;
 259   struct tag_struct tag;
 260   Gedcom_ctxt ctxt;
 261 }
 262
 263 %token_table
 264 %expect 308
 265
 266 %token <string> BADTOKEN
 267 %token <number> OPEN
 268 %token <string> CLOSE
 269 %token <string> ESCAPE
 270 %token <string> DELIM
 271 %token <string> ANYCHAR
 272 %token <string> POINTER
 273 %token <tag> USERTAG
 274 %token <tag> TAG_ABBR
 275 %token <tag> TAG_ADDR
 276 %token <tag> TAG_ADR1
 277 %token <tag> TAG_ADR2
 278 %token <tag> TAG_ADOP
 279 %token <tag> TAG_AFN
 280 %token <tag> TAG_AGE
 281 %token <tag> TAG_AGNC
 282 %token <tag> TAG_ALIA
 283 %token <tag> TAG_ANCE
 284 %token <tag> TAG_ANCI
 285 %token <tag> TAG_ANUL
 286 %token <tag> TAG_ASSO
 287 %token <tag> TAG_AUTH
 288 %token <tag> TAG_BAPL
 289 %token <tag> TAG_BAPM
 290 %token <tag> TAG_BARM
 291 %token <tag> TAG_BASM
 292 %token <tag> TAG_BIRT
 293 %token <tag> TAG_BLES
 294 %token <tag> TAG_BLOB
 295 %token <tag> TAG_BURI
 296 %token <tag> TAG_CALN
 297 %token <tag> TAG_CAST
 298 %token <tag> TAG_CAUS
 299 %token <tag> TAG_CENS
 300 %token <tag> TAG_CHAN
 301 %token <tag> TAG_CHAR
 302 %token <tag> TAG_CHIL
 303 %token <tag> TAG_CHR
 304 %token <tag> TAG_CHRA
 305 %token <tag> TAG_CITY
 306 %token <tag> TAG_CONC
 307 %token <tag> TAG_CONF
 308 %token <tag> TAG_CONL
 309 %token <tag> TAG_CONT
 310 %token <tag> TAG_COPR
 311 %token <tag> TAG_CORP
 312 %token <tag> TAG_CREM
 313 %token <tag> TAG_CTRY
 314 %token <tag> TAG_DATA
 315 %token <tag> TAG_DATE
 316 %token <tag> TAG_DEAT
 317 %token <tag> TAG_DESC
 318 %token <tag> TAG_DESI
 319 %token <tag> TAG_DEST
 320 %token <tag> TAG_DIV
 321 %token <tag> TAG_DIVF
 322 %token <tag> TAG_DSCR
 323 %token <tag> TAG_EDUC
 324 %token <tag> TAG_EMIG
 325 %token <tag> TAG_ENDL
 326 %token <tag> TAG_ENGA
 327 %token <tag> TAG_EVEN
 328 %token <tag> TAG_FAM
 329 %token <tag> TAG_FAMC
 330 %token <tag> TAG_FAMF
 331 %token <tag> TAG_FAMS
 332 %token <tag> TAG_FCOM
 333 %token <tag> TAG_FILE
 334 %token <tag> TAG_FORM
 335 %token <tag> TAG_GEDC
 336 %token <tag> TAG_GIVN
 337 %token <tag> TAG_GRAD
 338 %token <tag> TAG_HEAD
 339 %token <tag> TAG_HUSB
 340 %token <tag> TAG_IDNO
 341 %token <tag> TAG_IMMI
 342 %token <tag> TAG_INDI
 343 %token <tag> TAG_LANG
 344 %token <tag> TAG_LEGA
 345 %token <tag> TAG_MARB
 346 %token <tag> TAG_MARC
 347 %token <tag> TAG_MARL
 348 %token <tag> TAG_MARR
 349 %token <tag> TAG_MARS
 350 %token <tag> TAG_MEDI
 351 %token <tag> TAG_NAME
 352 %token <tag> TAG_NATI
 353 %token <tag> TAG_NATU
 354 %token <tag> TAG_NCHI
 355 %token <tag> TAG_NICK
 356 %token <tag> TAG_NMR
 357 %token <tag> TAG_NOTE
 358 %token <tag> TAG_NPFX
 359 %token <tag> TAG_NSFX
 360 %token <tag> TAG_OBJE
 361 %token <tag> TAG_OCCU
 362 %token <tag> TAG_ORDI
 363 %token <tag> TAG_ORDN
 364 %token <tag> TAG_PAGE
 365 %token <tag> TAG_PEDI
 366 %token <tag> TAG_PHON
 367 %token <tag> TAG_PLAC
 368 %token <tag> TAG_POST
 369 %token <tag> TAG_PROB
 370 %token <tag> TAG_PROP
 371 %token <tag> TAG_PUBL
 372 %token <tag> TAG_QUAY
 373 %token <tag> TAG_REFN
 374 %token <tag> TAG_RELA
 375 %token <tag> TAG_RELI
 376 %token <tag> TAG_REPO
 377 %token <tag> TAG_RESI
 378 %token <tag> TAG_RESN
 379 %token <tag> TAG_RETI
 380 %token <tag> TAG_RFN
 381 %token <tag> TAG_RIN
 382 %token <tag> TAG_ROLE
 383 %token <tag> TAG_SEX
 384 %token <tag> TAG_SLGC
 385 %token <tag> TAG_SLGS
 386 %token <tag> TAG_SOUR
 387 %token <tag> TAG_SPFX
 388 %token <tag> TAG_SSN
 389 %token <tag> TAG_STAE
 390 %token <tag> TAG_STAT
 391 %token <tag> TAG_SUBM
 392 %token <tag> TAG_SUBN
 393 %token <tag> TAG_SURN
 394 %token <tag> TAG_TEMP
 395 %token <tag> TAG_TEXT
 396 %token <tag> TAG_TIME
 397 %token <tag> TAG_TITL
 398 %token <tag> TAG_TRLR
 399 %token <tag> TAG_TYPE
 400 %token <tag> TAG_VERS
 401 %token <tag> TAG_WIFE
 402 %token <tag> TAG_WILL
 403
 404 %type <tag> anystdtag
 405 %type <tag> anytoptag
 406 %type <tag> fam_event_tag
 407 %type <tag> indiv_attr_tag
 408 %type <tag> indiv_birt_tag
 409 %type <tag> indiv_gen_tag
 410 %type <tag> lio_bapl_tag
 411 %type <string> line_item
 412 %type <string> mand_line_item
 413 %type <string> mand_pointer
 414 %type <string> note_line_item
 415 %type <string> anychar
 416 %type <string> opt_xref
 417 %type <string> opt_value
 418 %type <string> opt_line_item
 419 %type <ctxt> head_sect
 420
 421 %%
 422
 423 file        : head_sect records trlr_sect
 424                { if (fail == 1) YYABORT; }
 425             | error
 426                { clean_up(); }
 427             ;
 428
 429 records     : /* empty */
 430             | records record
 431             ;
 432
 433 record      : fam_rec
 434             | indiv_rec
 435             | multim_rec
 436             | note_rec
 437             | repos_rec
 438             | source_rec
 439             | submis_rec
 440             | submit_rec
 441             | no_std_rec
 442             ;
 443
 444 /*********************************************************************/
 445 /**** Header                                                      ****/
 446 /*********************************************************************/
 447 head_sect    : OPEN DELIM TAG_HEAD
 448                { $<ctxt>$ = start_record(REC_HEAD, $1, GEDCOM_MAKE_NULL(val1),
 449                                          $3,
 450                                          NULL, GEDCOM_MAKE_NULL(val2));
 451                  START(HEAD, $1, $<ctxt>$) }
 452                head_subs
 453                { if (compat_mode(C_NO_SUBMITTER) && ! CHK_COND(SUBM))
 454                    compat_generate_submitter_link($<ctxt>4);
 455                  else CHK(SUBM);
 456
 457                  if (compat_mode(C_NO_GEDC) && ! CHK_COND(GEDC))
 458                    compat_generate_gedcom($<ctxt>4);
 459                  else CHK(GEDC);
 460
 461                  if (compat_mode(C_NO_CHAR) && ! CHK_COND(CHAR)) {
 462                    if (compat_generate_char($<ctxt>4)) HANDLE_ERROR;
 463                  }
 464                  else CHK(CHAR);
 465
 466                  CHECK1(SOUR);
 467                }
 468                CLOSE
 469                { end_record(REC_HEAD, $<ctxt>4, GEDCOM_MAKE_NULL(val1));
 470                  if (compat_mode(C_NO_SUBMITTER))
 471                    compat_generate_submitter();
 472                }
 473              ;
 474
 475 head_subs    : /* empty */
 476              | head_subs head_sub
 477              ;
 478
 479 head_sub     : head_sour_sect  { OCCUR2(SOUR, 1, 1) }
 480              | head_dest_sect  { OCCUR2(DEST, 0, 1) }
 481              | head_date_sect  { OCCUR2(DATE, 0, 1) }
 482              | head_time_sect  { if (!compat_mode(C_HEAD_TIME))
 483                                   INVALID_TAG("TIME");
 484                                  OCCUR2(TIME, 0, 1) }
 485              | head_subm_sect  { OCCUR2(SUBM, 1, 1) }
 486              | head_subn_sect  { OCCUR2(SUBN, 0, 1) }
 487              | head_file_sect  { OCCUR2(FILE, 0, 1) }
 488              | head_copr_sect  { OCCUR2(COPR, 0, 1) }
 489              | head_gedc_sect  { OCCUR2(GEDC, 1, 1) }
 490              | head_char_sect  { OCCUR2(CHAR, 1, 1) }
 491              | head_lang_sect  { OCCUR2(LANG, 0, 1) }
 492              | head_plac_sect  { OCCUR2(PLAC, 0, 1) }
 493              | head_note_sect  { OCCUR2(NOTE, 0, 1) }
 494              | no_std_sub
 495              ;
 496
 497 /* HEAD.SOUR */
 498 head_sour_sect : OPEN DELIM TAG_SOUR mand_line_item
 499                  { set_compatibility_program($4);
 500                    $<ctxt>$ = start_element(ELT_HEAD_SOUR, PARENT,
 501                                             $1, $3, $4,
 502                                             GEDCOM_MAKE_STRING(val1, $4));
 503                    START(SOUR, $1, $<ctxt>$)
 504                  }
 505                  head_sour_subs
 506                  { CHECK0 }
 507                  CLOSE
 508                  { compute_compatibility();
 509                    end_element(ELT_HEAD_SOUR, PARENT, $<ctxt>5,
 510                                GEDCOM_MAKE_NULL(val1)); }
 511                ;
 512
 513 head_sour_subs : /* empty */
 514                | head_sour_subs head_sour_sub
 515                ;
 516
 517 head_sour_sub : head_sour_vers_sect  { OCCUR2(VERS, 0, 1) }
 518               | head_sour_name_sect  { OCCUR2(NAME, 0, 1) }
 519               | head_sour_corp_sect  { OCCUR2(CORP, 0, 1) }
 520               | head_sour_data_sect  { OCCUR2(DATA, 0, 1) }
 521               | no_std_sub
 522               ;
 523
 524 head_sour_vers_sect : OPEN DELIM TAG_VERS mand_line_item
 525                       { set_compatibility_version($4);
 526                         $<ctxt>$ = start_element(ELT_HEAD_SOUR_VERS, PARENT,
 527                                                  $1, $3, $4,
 528                                                  GEDCOM_MAKE_STRING(val1, $4));
 529                         START(VERS, $1, $<ctxt>$)
 530                       }
 531                       no_std_subs
 532                       { CHECK0 }
 533                       CLOSE
 534                       { end_element(ELT_HEAD_SOUR_VERS,
 535                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 536                       }
 537                     ;
 538 head_sour_name_sect : OPEN DELIM TAG_NAME mand_line_item
 539                       { $<ctxt>$ = start_element(ELT_HEAD_SOUR_NAME, PARENT,
 540                                                  $1, $3, $4,
 541                                                  GEDCOM_MAKE_STRING(val1, $4));
 542                         START(NAME, $1, $<ctxt>$)
 543                       }
 544                       no_std_subs
 545                       { CHECK0 }
 546                       CLOSE
 547                       { end_element(ELT_HEAD_SOUR_NAME,
 548                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 549                       }
 550                     ;
 551 head_sour_corp_sect : OPEN DELIM TAG_CORP mand_line_item
 552                       { $<ctxt>$ = start_element(ELT_HEAD_SOUR_CORP, PARENT,
 553                                                  $1, $3, $4,
 554                                                  GEDCOM_MAKE_STRING(val1, $4));
 555                         START(CORP, $1, $<ctxt>$)
 556                       }
 557                       head_sour_corp_subs
 558                       { CHECK0 }
 559                       CLOSE
 560                       { end_element(ELT_HEAD_SOUR_CORP,
 561                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 562                       }
 563                     ;
 564
 565 head_sour_corp_subs : /* empty */
 566                     | head_sour_corp_subs head_sour_corp_sub
 567                     ;
 568
 569 head_sour_corp_sub : addr_struc_sub  /* 0:1 */
 570                    | no_std_sub
 571                    ;
 572
 573 head_sour_data_sect : OPEN DELIM TAG_DATA mand_line_item
 574                       { $<ctxt>$ = start_element(ELT_HEAD_SOUR_DATA, PARENT,
 575                                                  $1, $3, $4,
 576                                                  GEDCOM_MAKE_STRING(val1, $4));
 577                         START(DATA, $1, $<ctxt>$)
 578                       }
 579                       head_sour_data_subs
 580                       { CHECK0 }
 581                       CLOSE
 582                       { end_element(ELT_HEAD_SOUR_DATA,
 583                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 584                       }
 585                     ;
 586
 587 head_sour_data_subs : /* empty */
 588                     | head_sour_data_subs head_sour_data_sub
 589                     ;
 590
 591 head_sour_data_sub : head_sour_data_date_sect  { OCCUR2(DATE, 0, 1) }
 592                    | head_sour_data_copr_sect  { OCCUR2(COPR, 0, 1) }
 593                    | no_std_sub
 594                    ;
 595
 596 head_sour_data_date_sect : OPEN DELIM TAG_DATE mand_line_item
 597                            { struct date_value dv = gedcom_parse_date($4);
 598                              $<ctxt>$
 599                                = start_element(ELT_HEAD_SOUR_DATA_DATE,
 600                                                PARENT, $1, $3, $4,
 601                                                GEDCOM_MAKE_DATE(val1, dv));
 602                              START(DATE, $1, $<ctxt>$)
 603                            }
 604                            no_std_subs
 605                            { CHECK0 }
 606                            CLOSE
 607                            { end_element(ELT_HEAD_SOUR_DATA_DATE,
 608                                          PARENT, $<ctxt>5,
 609                                          GEDCOM_MAKE_NULL(val1));
 610                            }
 611                          ;
 612 head_sour_data_copr_sect : OPEN DELIM TAG_COPR mand_line_item
 613                            { $<ctxt>$
 614                                = start_element(ELT_HEAD_SOUR_DATA_COPR,
 615                                                PARENT, $1, $3, $4,
 616                                                GEDCOM_MAKE_STRING(val1, $4));
 617                              START(COPR, $1, $<ctxt>$)
 618                            }
 619                            no_std_subs
 620                            { CHECK0 }
 621                            CLOSE
 622                            { end_element(ELT_HEAD_SOUR_DATA_COPR,
 623                                          PARENT, $<ctxt>5,
 624                                          GEDCOM_MAKE_NULL(val1));
 625                            }
 626                          ;
 627
 628 /* HEAD.DEST */
 629 head_dest_sect : OPEN DELIM TAG_DEST mand_line_item
 630                  { $<ctxt>$ = start_element(ELT_HEAD_DEST,
 631                                             PARENT, $1, $3, $4,
 632                                             GEDCOM_MAKE_STRING(val1, $4));
 633                    START(DEST, $1, $<ctxt>$)
 634                  }
 635                  no_std_subs
 636                  { CHECK0 }
 637                  CLOSE
 638                  { end_element(ELT_HEAD_DEST,
 639                                PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 640                  }
 641                ;
 642
 643 /* HEAD.DATE */
 644 head_date_sect : OPEN DELIM TAG_DATE mand_line_item
 645                  { struct date_value dv = gedcom_parse_date($4);
 646                    $<ctxt>$ = start_element(ELT_HEAD_DATE,
 647                                             PARENT, $1, $3, $4,
 648                                             GEDCOM_MAKE_DATE(val1, dv));
 649                    START(DATE, $1, $<ctxt>$)
 650                  }
 651                  head_date_subs
 652                  { CHECK0 }
 653                  CLOSE
 654                  { end_element(ELT_HEAD_DATE,
 655                                PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 656                  }
 657                ;
 658
 659 head_date_subs : /* empty */
 660                | head_date_subs head_date_sub
 661                ;
 662
 663 head_date_sub  : head_date_time_sect  { OCCUR2(TIME, 0, 1) }
 664                | no_std_sub
 665                ;
 666
 667 head_date_time_sect : OPEN DELIM TAG_TIME mand_line_item
 668                       { $<ctxt>$ = start_element(ELT_HEAD_DATE_TIME,
 669                                                  PARENT, $1, $3, $4,
 670                                                  GEDCOM_MAKE_STRING(val1, $4));
 671                         START(TIME, $1, $<ctxt>$)
 672                       }
 673                       no_std_subs
 674                       { CHECK0 }
 675                       CLOSE
 676                       { end_element(ELT_HEAD_DATE_TIME,
 677                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 678                       }
 679                     ;
 680
 681 /* HEAD.TIME (Only for compatibility) */
 682 /* Just ignore the time... */
 683 head_time_sect : OPEN DELIM TAG_TIME opt_line_item CLOSE
 684                  { gedcom_warning(_("Header change time lost in the compatibility"));
 685                  }
 686                ;
 687
 688 /* HEAD.SUBM */
 689 head_subm_sect : OPEN DELIM TAG_SUBM mand_pointer
 690                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
 691                                                              XREF_SUBM);
 692                    if (xr == NULL) HANDLE_ERROR;
 693                    $<ctxt>$ = start_element(ELT_HEAD_SUBM,
 694                                             PARENT, $1, $3, $4,
 695                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
 696                    START(SUBM, $1, $<ctxt>$)
 697                  }
 698                  no_std_subs
 699                  { CHECK0 }
 700                  CLOSE
 701                  { end_element(ELT_HEAD_SUBM,
 702                                PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 703                  }
 704                ;
 705 /* HEAD.SUBN */
 706 head_subn_sect : OPEN DELIM TAG_SUBN mand_pointer
 707                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
 708                                                              XREF_SUBN);
 709                    if (xr == NULL) HANDLE_ERROR;
 710                    $<ctxt>$ = start_element(ELT_HEAD_SUBN,
 711                                             PARENT, $1, $3, $4,
 712                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
 713                    START(SUBN, $1, $<ctxt>$)
 714                  }
 715                  no_std_subs
 716                  { CHECK0 }
 717                  CLOSE
 718                  { end_element(ELT_HEAD_SUBN,
 719                                PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 720                  }
 721                ;
 722 /* HEAD.FILE */
 723 head_file_sect : OPEN DELIM TAG_FILE mand_line_item
 724                  { $<ctxt>$ = start_element(ELT_HEAD_FILE,
 725                                             PARENT, $1, $3, $4,
 726                                             GEDCOM_MAKE_STRING(val1, $4));
 727                    START(FILE, $1, $<ctxt>$)
 728                  }
 729                  no_std_subs
 730                  { CHECK0 }
 731                  CLOSE
 732                  { end_element(ELT_HEAD_FILE, PARENT, $<ctxt>5,
 733                                GEDCOM_MAKE_NULL(val1));
 734                  }
 735                ;
 736 /* HEAD.COPR */
 737 head_copr_sect : OPEN DELIM TAG_COPR mand_line_item
 738                  { $<ctxt>$ = start_element(ELT_HEAD_COPR,
 739                                             PARENT, $1, $3, $4,
 740                                             GEDCOM_MAKE_STRING(val1, $4));
 741                    START(COPR, $1, $<ctxt>$)
 742                  }
 743                  no_std_subs
 744                  { CHECK0 }
 745                  CLOSE
 746                  { end_element(ELT_HEAD_COPR, PARENT, $<ctxt>5,
 747                                GEDCOM_MAKE_NULL(val1));
 748                  }
 749                ;
 750 /* HEAD.GEDC */
 751 head_gedc_sect : OPEN DELIM TAG_GEDC
 752                  { $<ctxt>$ = start_element(ELT_HEAD_GEDC,
 753                                             PARENT, $1, $3, NULL,
 754                                             GEDCOM_MAKE_NULL(val1));
 755                    START(GEDC, $1, $<ctxt>$)
 756                  }
 757                  head_gedc_subs
 758                  { CHECK2(VERS, FORM) }
 759                  CLOSE
 760                  { end_element(ELT_HEAD_GEDC, PARENT, $<ctxt>4,
 761                                GEDCOM_MAKE_NULL(val1));
 762                  }
 763                ;
 764
 765 head_gedc_subs : /* empty */
 766                | head_gedc_subs head_gedc_sub
 767                ;
 768
 769 head_gedc_sub  : head_gedc_vers_sect  { OCCUR2(VERS, 1, 1) }
 770                | head_gedc_form_sect  { OCCUR2(FORM, 1, 1) }
 771                | no_std_sub
 772                ;
 773 head_gedc_vers_sect : OPEN DELIM TAG_VERS mand_line_item
 774                       { $<ctxt>$ = start_element(ELT_HEAD_GEDC_VERS,
 775                                                  PARENT, $1, $3, $4,
 776                                                  GEDCOM_MAKE_STRING(val1, $4));
 777                         START(VERS, $1, $<ctxt>$)
 778                       }
 779                       no_std_subs
 780                       { CHECK0 }
 781                       CLOSE
 782                       { end_element(ELT_HEAD_GEDC_VERS,
 783                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 784                       }
 785                     ;
 786 head_gedc_form_sect : OPEN DELIM TAG_FORM mand_line_item
 787                       { $<ctxt>$ = start_element(ELT_HEAD_GEDC_FORM,
 788                                                  PARENT, $1, $3, $4,
 789                                                  GEDCOM_MAKE_STRING(val1, $4));
 790                         START(FORM, $1, $<ctxt>$)
 791                       }
 792                       no_std_subs
 793                       { CHECK0 }
 794                       CLOSE
 795                       { end_element(ELT_HEAD_GEDC_FORM,
 796                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 797                       }
 798                     ;
 799
 800 /* HEAD.CHAR */
 801 head_char_sect : OPEN DELIM TAG_CHAR mand_line_item
 802                  { /* Don't allow to continue if conversion context couldn't
 803                       be opened */
 804                    if (open_conv_to_internal($4) == 0) HANDLE_ERROR;
 805                    $<ctxt>$ = start_element(ELT_HEAD_CHAR,
 806                                             PARENT, $1, $3, $4,
 807                                             GEDCOM_MAKE_STRING(val1, $4));
 808                    START(CHAR, $1, $<ctxt>$)
 809                  }
 810                  head_char_subs
 811                  { CHECK0 }
 812                  CLOSE
 813                  { end_element(ELT_HEAD_CHAR, PARENT, $<ctxt>5,
 814                                GEDCOM_MAKE_NULL(val1));
 815                  }
 816                ;
 817
 818 head_char_subs : /* empty */
 819                | head_char_subs head_char_sub
 820                ;
 821
 822 head_char_sub  : head_char_vers_sect  { OCCUR2(VERS, 0, 1) }
 823                | no_std_sub
 824                ;
 825 head_char_vers_sect : OPEN DELIM TAG_VERS mand_line_item
 826                       { $<ctxt>$ = start_element(ELT_HEAD_CHAR_VERS,
 827                                                  PARENT, $1, $3, $4,
 828                                                  GEDCOM_MAKE_STRING(val1, $4));
 829                         START(VERS, $1, $<ctxt>$)
 830                       }
 831                       no_std_subs
 832                       { CHECK0 }
 833                       CLOSE
 834                       { end_element(ELT_HEAD_CHAR_VERS,
 835                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 836                       }
 837                     ;
 838
 839 /* HEAD.LANG */
 840 head_lang_sect : OPEN DELIM TAG_LANG mand_line_item
 841                  { $<ctxt>$ = start_element(ELT_HEAD_LANG,
 842                                             PARENT, $1, $3, $4,
 843                                             GEDCOM_MAKE_STRING(val1, $4));
 844                    START(LANG, $1, $<ctxt>$)
 845                  }
 846                  no_std_subs
 847                  { CHECK0 }
 848                  CLOSE
 849                  { end_element(ELT_HEAD_LANG, PARENT, $<ctxt>5,
 850                                GEDCOM_MAKE_NULL(val1));
 851                  }
 852                ;
 853 /* HEAD.PLAC */
 854 head_plac_sect : OPEN DELIM TAG_PLAC
 855                  { $<ctxt>$ = start_element(ELT_HEAD_PLAC,
 856                                             PARENT, $1, $3, NULL,
 857                                             GEDCOM_MAKE_NULL(val1));
 858                    START(PLAC, $1, $<ctxt>$)
 859                  }
 860                  head_plac_subs
 861                  { CHECK1(FORM) }
 862                  CLOSE
 863                  { end_element(ELT_HEAD_PLAC, PARENT, $<ctxt>4,
 864                                GEDCOM_MAKE_NULL(val1));
 865                  }
 866                ;
 867
 868 head_plac_subs : /* empty */
 869                | head_plac_subs head_plac_sub
 870                ;
 871
 872 head_plac_sub  : head_plac_form_sect  { OCCUR2(FORM, 1, 1) }
 873                | no_std_sub
 874                ;
 875 head_plac_form_sect : OPEN DELIM TAG_FORM mand_line_item
 876                       { $<ctxt>$ = start_element(ELT_HEAD_PLAC_FORM,
 877                                                  PARENT, $1, $3, $4,
 878                                                  GEDCOM_MAKE_STRING(val1, $4));
 879                         START(FORM, $1, $<ctxt>$)
 880                       }
 881                       no_std_subs
 882                       { CHECK0 }
 883                       CLOSE
 884                       { end_element(ELT_HEAD_PLAC_FORM,
 885                                     PARENT, $<ctxt>5, GEDCOM_MAKE_NULL(val1));
 886                       }
 887                     ;
 888
 889 /* HEAD.NOTE */
 890 head_note_sect : OPEN DELIM TAG_NOTE mand_line_item
 891                  { $<ctxt>$ = start_element(ELT_HEAD_NOTE,
 892                                             PARENT, $1, $3, $4,
 893                                             GEDCOM_MAKE_STRING(val1, $4));
 894                    reset_buffer(&concat_buffer);
 895                    safe_buf_append(&concat_buffer, $4);
 896                    START(NOTE, $1, $<ctxt>$)
 897                  }
 898                  head_note_subs
 899                  { CHECK0 }
 900                  CLOSE
 901                  { char* complete = get_buf_string(&concat_buffer);
 902                    end_element(ELT_HEAD_NOTE, PARENT, $<ctxt>5,
 903                                GEDCOM_MAKE_STRING(val1, complete));
 904                  }
 905                ;
 906
 907 head_note_subs : /* empty */
 908                | head_note_subs head_note_sub
 909                ;
 910
 911 head_note_sub  : continuation_sub  /* 0:M */
 912                | no_std_sub
 913                ;
 914
 915 /*********************************************************************/
 916 /**** Trailer                                                     ****/
 917 /*********************************************************************/
 918 /* Don't need callbacks here, there is no information... */
 919 trlr_sect   : OPEN DELIM TAG_TRLR CLOSE { }
 920             ;
 921
 922 /*********************************************************************/
 923 /**** Family record                                               ****/
 924 /*********************************************************************/
 925 fam_rec      : OPEN DELIM POINTER DELIM TAG_FAM
 926                { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
 927                                                            XREF_FAM);
 928                  if (xr == NULL) HANDLE_ERROR;
 929                  $<ctxt>$ = start_record(REC_FAM,
 930                                          $1, GEDCOM_MAKE_XREF_PTR(val1, xr),
 931                                          $5,
 932                                          NULL, GEDCOM_MAKE_NULL(val2));
 933                  START(FAM, $1, $<ctxt>$) }
 934                fam_subs
 935                { CHECK0 }
 936                CLOSE
 937                { end_record(REC_FAM, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
 938              ;
 939
 940 fam_subs     : /* empty */
 941              | fam_subs fam_sub
 942              ;
 943
 944 fam_sub      : fam_event_struc_sub  /* 0:M */
 945              | fam_husb_sect  { OCCUR2(HUSB, 0, 1) }
 946              | fam_wife_sect  { OCCUR2(WIFE, 0, 1) }
 947              | fam_chil_sect  /* 0:M */
 948              | fam_nchi_sect  { OCCUR2(NCHI, 0, 1) }
 949              | fam_subm_sect  /* 0:M */
 950              | lds_spouse_seal_sub  /* 0:M */
 951              | source_cit_sub  /* 0:M */
 952              | multim_link_sub  /* 0:M */
 953              | note_struc_sub  /* 0:M */
 954              | ident_struc_sub  /* 0:1 */
 955              | change_date_sub  /* 0:1 */
 956              | no_std_sub
 957              ;
 958
 959 /* FAM.HUSB */
 960 fam_husb_sect : OPEN DELIM TAG_HUSB mand_pointer
 961                 { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
 962                                                             XREF_INDI);
 963                   if (xr == NULL) HANDLE_ERROR;
 964                   $<ctxt>$ = start_element(ELT_FAM_HUSB,
 965                                            PARENT, $1, $3, $4,
 966                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
 967                   START(HUSB, $1, $<ctxt>$)
 968                 }
 969                 no_std_subs
 970                 { CHECK0 }
 971                 CLOSE
 972                 { end_element(ELT_FAM_HUSB, PARENT, $<ctxt>5,
 973                               GEDCOM_MAKE_NULL(val1));
 974                 }
 975               ;
 976
 977 /* FAM.WIFE */
 978 fam_wife_sect : OPEN DELIM TAG_WIFE mand_pointer
 979                 { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
 980                                                             XREF_INDI);
 981                   if (xr == NULL) HANDLE_ERROR;
 982                   $<ctxt>$ = start_element(ELT_FAM_WIFE,
 983                                            PARENT, $1, $3, $4,
 984                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
 985                   START(WIFE, $1, $<ctxt>$)
 986                 }
 987                 no_std_subs
 988                 { CHECK0 }
 989                 CLOSE
 990                 { end_element(ELT_FAM_WIFE, PARENT, $<ctxt>5,
 991                               GEDCOM_MAKE_NULL(val1));
 992                 }
 993               ;
 994
 995 /* FAM.CHIL */
 996 fam_chil_sect : OPEN DELIM TAG_CHIL mand_pointer
 997                 { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
 998                                                             XREF_INDI);
 999                   if (xr == NULL) HANDLE_ERROR;
1000                   $<ctxt>$ = start_element(ELT_FAM_CHIL,
1001                                            PARENT, $1, $3, $4,
1002                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
1003                   START(CHIL, $1, $<ctxt>$)
1004                 }
1005                 no_std_subs
1006                 { CHECK0 }
1007                 CLOSE
1008                 { end_element(ELT_FAM_CHIL, PARENT, $<ctxt>5,
1009                               GEDCOM_MAKE_NULL(val1));
1010                 }
1011               ;
1012
1013 /* FAM.NCHI */
1014 fam_nchi_sect : OPEN DELIM TAG_NCHI mand_line_item
1015                 { $<ctxt>$ = start_element(ELT_FAM_NCHI,
1016                                            PARENT, $1, $3, $4,
1017                                            GEDCOM_MAKE_STRING(val1, $4));
1018                   START(NCHI, $1, $<ctxt>$)
1019                 }
1020                 no_std_subs
1021                 { CHECK0 }
1022                 CLOSE
1023                 { end_element(ELT_FAM_NCHI, PARENT, $<ctxt>5,
1024                               GEDCOM_MAKE_NULL(val1));
1025                 }
1026               ;
1027
1028 /* FAM.SUBM */
1029 fam_subm_sect : OPEN DELIM TAG_SUBM mand_pointer
1030                 { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1031                                                             XREF_SUBM);
1032                   if (xr == NULL) HANDLE_ERROR;
1033                   $<ctxt>$ = start_element(ELT_FAM_SUBM,
1034                                            PARENT, $1, $3, $4,
1035                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
1036                   START(SUBM, $1, $<ctxt>$)
1037                 }
1038                 no_std_subs
1039                 { CHECK0 }
1040                 CLOSE
1041                 { end_element(ELT_FAM_SUBM, PARENT, $<ctxt>5,
1042                               GEDCOM_MAKE_NULL(val1));
1043                 }
1044               ;
1045
1046 /*********************************************************************/
1047 /**** Individual record                                           ****/
1048 /*********************************************************************/
1049 indiv_rec   : OPEN DELIM POINTER DELIM TAG_INDI
1050               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1051                                                           XREF_INDI);
1052                 if (xr == NULL) HANDLE_ERROR;
1053                 $<ctxt>$ = start_record(REC_INDI,
1054                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1055                                         NULL, GEDCOM_MAKE_NULL(val2));
1056                 START(INDI, $1, $<ctxt>$) }
1057               indi_subs
1058               { CHECK0 }
1059               CLOSE
1060               { end_record(REC_INDI, $<ctxt>6, GEDCOM_MAKE_NULL(val1));
1061                 if (compat_mode(C_NO_SLGC_FAMC))
1062                   compat_generate_slgc_famc_fam();
1063               }
1064             ;
1065
1066 indi_subs   : /* empty */
1067             | indi_subs indi_sub
1068             ;
1069
1070 indi_sub    : indi_resn_sect  { OCCUR2(RESN, 0, 1) }
1071             | pers_name_struc_sub  /* 0:M */
1072             | indi_sex_sect  { OCCUR2(SEX, 0, 1) }
1073             | indiv_even_struc_sub  /* 0:M */
1074             | indiv_attr_struc_sub  /* 0:M */
1075             | lds_indiv_ord_sub  /* 0:M */
1076             | chi_fam_link_sub  /* 0:M */
1077             | spou_fam_link_sub  /* 0:M */
1078             | indi_subm_sect  /* 0:M */
1079             | assoc_struc_sub  /* 0:M */
1080             | indi_alia_sect  /* 0:M */
1081             | indi_anci_sect  /* 0:M */
1082             | indi_desi_sect  /* 0:M */
1083             | source_cit_sub  /* 0:M */
1084             | multim_link_sub  /* 0:M */
1085             | note_struc_sub  /* 0:M */
1086             | indi_rfn_sect  { OCCUR2(RFN, 0, 1) }
1087             | indi_afn_sect  /* 0:M */
1088             | ident_struc_sub  /* 0:1 */
1089             | change_date_sub  /* 0:1 */
1090             | indi_addr_sect { if (!compat_mode(C_INDI_ADDR))
1091                                   INVALID_TAG("ADDR");
1092                               }
1093             | no_std_sub
1094             ;
1095
1096 /* INDI.RESN */
1097 indi_resn_sect : OPEN DELIM TAG_RESN mand_line_item
1098                  { $<ctxt>$ = start_element(ELT_INDI_RESN,
1099                                             PARENT, $1, $3, $4,
1100                                             GEDCOM_MAKE_STRING(val1, $4));
1101                    START(RESN, $1, $<ctxt>$)
1102                  }
1103                  no_std_subs
1104                  { CHECK0 }
1105                  CLOSE
1106                  { end_element(ELT_INDI_RESN, PARENT, $<ctxt>5,
1107                                GEDCOM_MAKE_NULL(val1));
1108                  }
1109                ;
1110
1111 /* INDI.SEX */
1112 indi_sex_sect  : OPEN DELIM TAG_SEX mand_line_item
1113                  { $<ctxt>$ = start_element(ELT_INDI_SEX,
1114                                             PARENT, $1, $3, $4,
1115                                             GEDCOM_MAKE_STRING(val1, $4));
1116                    START(SEX, $1, $<ctxt>$)
1117                  }
1118                  no_std_subs
1119                  { CHECK0 }
1120                  CLOSE
1121                  { end_element(ELT_INDI_SEX, PARENT, $<ctxt>5,
1122                                GEDCOM_MAKE_NULL(val1));
1123                  }
1124                ;
1125
1126 /* INDI.SUBM */
1127 indi_subm_sect : OPEN DELIM TAG_SUBM mand_pointer
1128                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1129                                                              XREF_SUBM);
1130                    if (xr == NULL) HANDLE_ERROR;
1131                    $<ctxt>$ = start_element(ELT_INDI_SUBM,
1132                                             PARENT, $1, $3, $4,
1133                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1134                    START(SUBM, $1, $<ctxt>$)
1135                  }
1136                  no_std_subs
1137                  { CHECK0 }
1138                  CLOSE
1139                  { end_element(ELT_INDI_SUBM, PARENT, $<ctxt>5,
1140                                GEDCOM_MAKE_NULL(val1));
1141                  }
1142                ;
1143
1144 /* INDI.ALIA */
1145 indi_alia_sect : OPEN DELIM TAG_ALIA mand_pointer
1146                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1147                                                              XREF_INDI);
1148                    if (xr == NULL) HANDLE_ERROR;
1149                    $<ctxt>$ = start_element(ELT_INDI_ALIA,
1150                                             PARENT, $1, $3, $4,
1151                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1152                    START(ALIA, $1, $<ctxt>$)
1153                  }
1154                  no_std_subs
1155                  { CHECK0 }
1156                  CLOSE
1157                  { end_element(ELT_INDI_ALIA, PARENT, $<ctxt>5,
1158                                GEDCOM_MAKE_NULL(val1));
1159                  }
1160                ;
1161
1162 /* INDI.ANCI */
1163 indi_anci_sect : OPEN DELIM TAG_ANCI mand_pointer
1164                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1165                                                              XREF_SUBM);
1166                    if (xr == NULL) HANDLE_ERROR;
1167                    $<ctxt>$ = start_element(ELT_INDI_ANCI,
1168                                             PARENT, $1, $3, $4,
1169                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1170                    START(ANCI, $1, $<ctxt>$)
1171                  }
1172                  no_std_subs
1173                  { CHECK0 }
1174                  CLOSE
1175                  { end_element(ELT_INDI_ANCI, PARENT, $<ctxt>5,
1176                                GEDCOM_MAKE_NULL(val1));
1177                  }
1178                ;
1179
1180 /* INDI.DESI */
1181 indi_desi_sect : OPEN DELIM TAG_DESI mand_pointer
1182                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1183                                                              XREF_SUBM);
1184                    if (xr == NULL) HANDLE_ERROR;
1185                    $<ctxt>$ = start_element(ELT_INDI_DESI,
1186                                             PARENT, $1, $3, $4,
1187                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1188                    START(DESI, $1, $<ctxt>$)
1189                  }
1190                  no_std_subs
1191                  { CHECK0 }
1192                  CLOSE
1193                  { end_element(ELT_INDI_DESI, PARENT, $<ctxt>5,
1194                                GEDCOM_MAKE_NULL(val1));
1195                  }
1196                ;
1197
1198 /* INDI.RFN */
1199 indi_rfn_sect  : OPEN DELIM TAG_RFN mand_line_item
1200                  { $<ctxt>$ = start_element(ELT_INDI_RFN,
1201                                             PARENT, $1, $3, $4,
1202                                             GEDCOM_MAKE_STRING(val1, $4));
1203                    START(RFN, $1, $<ctxt>$)
1204                  }
1205                  no_std_subs
1206                  { CHECK0 }
1207                  CLOSE
1208                  { end_element(ELT_INDI_RFN, PARENT, $<ctxt>5,
1209                                GEDCOM_MAKE_NULL(val1));
1210                  }
1211                ;
1212
1213 /* INDI.AFN */
1214 indi_afn_sect  : OPEN DELIM TAG_AFN mand_line_item
1215                  { $<ctxt>$ = start_element(ELT_INDI_AFN,
1216                                             PARENT, $1, $3, $4,
1217                                             GEDCOM_MAKE_STRING(val1, $4));
1218                    START(AFN, $1, $<ctxt>$)
1219                  }
1220                  no_std_subs
1221                  { CHECK0 }
1222                  CLOSE
1223                  { end_element(ELT_INDI_AFN, PARENT, $<ctxt>5,
1224                                GEDCOM_MAKE_NULL(val1));
1225                  }
1226                ;
1227
1228 /* INDI.ADDR (Only for compatibility) */
1229 indi_addr_sect : OPEN DELIM TAG_ADDR opt_line_item
1230                   { if (compat_mode(C_INDI_ADDR)) {
1231                       Gedcom_ctxt par = compat_generate_resi_start(PARENT);
1232                       START(RESI, $1, par);
1233                       $<ctxt>$
1234                         = start_element(ELT_SUB_ADDR,
1235                                         par, $1 + 1, $3, $4,
1236                                         GEDCOM_MAKE_NULL_OR_STRING(val2, $4));
1237                       START(ADDR, $1 + 1, $<ctxt>$);
1238                     }
1239                   else { START(ADDR, $1, NULL) }
1240                   }
1241                   ftree_addr_subs
1242                   { CHECK0 }
1243                   CLOSE
1244                   { if (compat_mode(C_INDI_ADDR)) {
1245                       Gedcom_ctxt par = PARENT;
1246                       end_element(ELT_SUB_ADDR, par, $<ctxt>5,
1247                                   GEDCOM_MAKE_NULL(val1));
1248                       CHECK0;
1249                       compat_generate_resi_end(PARENT, par);
1250                     }
1251                   }
1252                 ;
1253
1254 ftree_addr_subs : /* empty */
1255                 | ftree_addr_subs ftree_addr_sub
1256                 ;
1257
1258 ftree_addr_sub  : continuation_sub
1259                 | ftree_addr_phon_sect
1260                 | no_std_sub
1261                 ;
1262
1263 ftree_addr_phon_sect : OPEN DELIM TAG_PHON mand_line_item
1264                        { $<ctxt>$
1265                            = start_element(ELT_SUB_PHON,
1266                                            GRANDPARENT(1), $1, $3, $4,
1267                                            GEDCOM_MAKE_STRING(val1, $4));
1268                          START(PHON, $1, $<ctxt>$)
1269                        }
1270                        no_std_subs
1271                        { CHECK0 }
1272                        CLOSE
1273                        { end_element(ELT_SUB_PHON, GRANDPARENT(1),
1274                                      $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1275                        }
1276             ;
1277
1278 /*********************************************************************/
1279 /**** Multimedia record                                           ****/
1280 /*********************************************************************/
1281 multim_rec  : OPEN DELIM POINTER DELIM TAG_OBJE
1282               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1283                                                           XREF_OBJE);
1284                 if (xr == NULL) HANDLE_ERROR;
1285                 $<ctxt>$ = start_record(REC_OBJE,
1286                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1287                                         NULL, GEDCOM_MAKE_NULL(val2));
1288                 START(OBJE, $1, $<ctxt>$) }
1289               obje_subs
1290               { CHECK2(FORM, BLOB) }
1291               CLOSE
1292               { end_record(REC_OBJE, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
1293             ;
1294
1295 obje_subs   : /* empty */
1296             | obje_subs obje_sub
1297             ;
1298
1299 obje_sub    : obje_form_sect  { OCCUR2(FORM, 1, 1) }
1300             | obje_titl_sect  { OCCUR2(TITL, 0, 1) }
1301             | note_struc_sub  /* 0:M */
1302             | obje_blob_sect  { OCCUR2(BLOB, 1, 1) }
1303             | obje_obje_sect  { OCCUR2(OBJE, 0, 1) }
1304             | ident_struc_sub  /* 0:1 */
1305             | change_date_sub  /* 0:1 */
1306             | no_std_sub
1307             ;
1308
1309 /* OBJE.FORM */
1310 obje_form_sect : OPEN DELIM TAG_FORM mand_line_item
1311                  { $<ctxt>$ = start_element(ELT_OBJE_FORM,
1312                                             PARENT, $1, $3, $4,
1313                                             GEDCOM_MAKE_STRING(val1, $4));
1314                    START(FORM, $1, $<ctxt>$)
1315                  }
1316                  no_std_subs
1317                  { CHECK0 }
1318                  CLOSE
1319                  { end_element(ELT_OBJE_FORM, PARENT, $<ctxt>5,
1320                                GEDCOM_MAKE_NULL(val1));
1321                  }
1322                ;
1323
1324 /* OBJE.TITL */
1325 obje_titl_sect : OPEN DELIM TAG_TITL mand_line_item
1326                  { $<ctxt>$ = start_element(ELT_OBJE_TITL,
1327                                             PARENT, $1, $3, $4,
1328                                             GEDCOM_MAKE_STRING(val1, $4));
1329                    START(TITL, $1, $<ctxt>$)
1330                  }
1331                  no_std_subs
1332                  { CHECK0 }
1333                  CLOSE
1334                  { end_element(ELT_OBJE_TITL, PARENT, $<ctxt>5,
1335                                GEDCOM_MAKE_NULL(val1));
1336                  }
1337                ;
1338
1339 /* OBJE.BLOB */
1340 obje_blob_sect : OPEN DELIM TAG_BLOB
1341                  { $<ctxt>$ = start_element(ELT_OBJE_BLOB,
1342                                             PARENT, $1, $3, NULL,
1343                                             GEDCOM_MAKE_NULL(val1));
1344                    reset_buffer(&concat_buffer);
1345                    START(BLOB, $1, $<ctxt>$)
1346                  }
1347                  obje_blob_subs
1348                  { CHECK1(CONT) }
1349                  CLOSE
1350                  { char* complete = get_buf_string(&concat_buffer);
1351                    end_element(ELT_OBJE_BLOB, PARENT, $<ctxt>4,
1352                                GEDCOM_MAKE_STRING(val1, complete));
1353                  }
1354                ;
1355
1356 obje_blob_subs : /* empty */
1357                | obje_blob_subs obje_blob_sub
1358                ;
1359
1360 obje_blob_sub  : obje_blob_cont_sect  { OCCUR1(CONT, 1) }
1361                | no_std_sub
1362                ;
1363
1364 obje_blob_cont_sect : OPEN DELIM TAG_CONT mand_line_item
1365                       { $<ctxt>$ = start_element(ELT_OBJE_BLOB_CONT,
1366                                                  PARENT, $1, $3, $4,
1367                                                  GEDCOM_MAKE_STRING(val1, $4));
1368                         safe_buf_append(&concat_buffer, $4);
1369                         START(CONT, $1, $<ctxt>$)
1370                       }
1371                       no_std_subs
1372                       { CHECK0 }
1373                       CLOSE
1374                       { end_element(ELT_OBJE_BLOB_CONT, PARENT,
1375                                     $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1376                       }
1377                     ;
1378
1379 /* OBJE.OBJE */
1380 obje_obje_sect : OPEN DELIM TAG_OBJE mand_pointer
1381                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1382                                                              XREF_OBJE);
1383                    if (xr == NULL) HANDLE_ERROR;
1384                    $<ctxt>$ = start_element(ELT_OBJE_OBJE,
1385                                             PARENT, $1, $3, $4,
1386                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1387                    START(OBJE, $1, $<ctxt>$)
1388                  }
1389                  no_std_subs
1390                  { CHECK0 }
1391                  CLOSE
1392                  { end_element(ELT_OBJE_OBJE, PARENT, $<ctxt>5,
1393                                GEDCOM_MAKE_NULL(val1));
1394                  }
1395                ;
1396
1397 /*********************************************************************/
1398 /**** Note record                                                 ****/
1399 /*********************************************************************/
1400 note_rec    : OPEN DELIM POINTER DELIM TAG_NOTE note_line_item
1401               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1402                                                           XREF_NOTE);
1403                 if (xr == NULL) HANDLE_ERROR;
1404                 $<ctxt>$ = start_record(REC_NOTE,
1405                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1406                                         $6, GEDCOM_MAKE_STRING(val2, $6));
1407                 reset_buffer(&concat_buffer);
1408                 safe_buf_append(&concat_buffer, $6);
1409                 START(NOTE, $1, $<ctxt>$) }
1410               note_subs
1411               { CHECK0 }
1412               CLOSE
1413               { char* complete = get_buf_string(&concat_buffer);
1414                 end_record(REC_NOTE, $<ctxt>7,
1415                            GEDCOM_MAKE_STRING(val1, complete)); }
1416             ;
1417
1418 note_line_item : /* empty */
1419                    { if (!compat_mode(C_NOTE_NO_VALUE)) {
1420                        gedcom_error(_("Missing value")); YYERROR;
1421                      }
1422                      else {
1423                        $$ = "";
1424                      }
1425                    }
1426                | DELIM line_item
1427                    { gedcom_debug_print("==Val: %s==", $2);
1428                      $$ = $2; }
1429                ;
1430
1431 note_subs   : /* empty */
1432             | note_subs note_sub
1433             ;
1434
1435 note_sub    : continuation_sub  /* 0:M */
1436             | source_cit_sub  /* 0:M */
1437             | ident_struc_sub  /* 0:1 */
1438             | change_date_sub  /* 0:1 */
1439             | no_std_sub
1440             ;
1441
1442 /*********************************************************************/
1443 /**** Repository record                                           ****/
1444 /*********************************************************************/
1445 repos_rec   : OPEN DELIM POINTER DELIM TAG_REPO
1446               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1447                                                           XREF_REPO);
1448                 if (xr == NULL) HANDLE_ERROR;
1449                 $<ctxt>$ = start_record(REC_REPO,
1450                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1451                                         NULL, GEDCOM_MAKE_NULL(val2));
1452                 START(REPO, $1, $<ctxt>$) }
1453               repo_subs
1454               { CHECK0 }
1455               CLOSE
1456               { end_record(REC_REPO, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
1457             ;
1458
1459 repo_subs   : /* empty */
1460             | repo_subs repo_sub
1461             ;
1462
1463 repo_sub    : repo_name_sect  { OCCUR2(NAME, 0, 1) }
1464             | addr_struc_sub  /* 0:1 */
1465             | note_struc_sub  /* 0:M */
1466             | ident_struc_sub  /* 0:1 */
1467             | change_date_sub  /* 0:1 */
1468             | no_std_sub
1469             ;
1470
1471 /* REPO.NAME */
1472 repo_name_sect : OPEN DELIM TAG_NAME mand_line_item
1473                  { $<ctxt>$ = start_element(ELT_REPO_NAME,
1474                                             PARENT, $1, $3, $4,
1475                                             GEDCOM_MAKE_STRING(val1, $4));
1476                    START(NAME, $1, $<ctxt>$)
1477                  }
1478                  no_std_subs
1479                  { CHECK0 }
1480                  CLOSE
1481                  { end_element(ELT_REPO_NAME, PARENT, $<ctxt>5,
1482                                GEDCOM_MAKE_NULL(val1));
1483                  }
1484                ;
1485
1486 /*********************************************************************/
1487 /**** Source record                                               ****/
1488 /*********************************************************************/
1489 source_rec  : OPEN DELIM POINTER DELIM TAG_SOUR
1490               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1491                                                           XREF_SOUR);
1492                 if (xr == NULL) HANDLE_ERROR;
1493                 $<ctxt>$ = start_record(REC_SOUR,
1494                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1495                                         NULL, GEDCOM_MAKE_NULL(val2));
1496                 START(SOUR, $1, $<ctxt>$) }
1497               sour_subs
1498               { CHECK0 }
1499               CLOSE
1500               { end_record(REC_SOUR, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
1501             ;
1502
1503 sour_subs   : /* empty */
1504             | sour_subs sour_sub
1505             ;
1506
1507 sour_sub    : sour_data_sect  { OCCUR2(DATA, 0, 1) }
1508             | sour_auth_sect  { OCCUR2(AUTH, 0, 1) }
1509             | sour_titl_sect  { OCCUR2(TITL, 0, 1) }
1510             | sour_abbr_sect  { OCCUR2(ABBR, 0, 1) }
1511             | sour_publ_sect  { OCCUR2(PUBL, 0, 1) }
1512             | sour_text_sect  { OCCUR2(TEXT, 0, 1) }
1513             | source_repos_cit_sub  /* 0:1 */
1514             | multim_link_sub  /* 0:M */
1515             | note_struc_sub  /* 0:M */
1516             | ident_struc_sub  /* 0:1 */
1517             | change_date_sub  /* 0:1 */
1518             | no_std_sub
1519             ;
1520
1521 /* SOUR.DATA */
1522 sour_data_sect : OPEN DELIM TAG_DATA
1523                  { $<ctxt>$ = start_element(ELT_SOUR_DATA,
1524                                             PARENT, $1, $3, NULL,
1525                                             GEDCOM_MAKE_NULL(val1));
1526                    START(DATA, $1, $<ctxt>$)
1527                  }
1528                  sour_data_subs
1529                  { CHECK0 }
1530                  CLOSE
1531                  { end_element(ELT_SOUR_DATA, PARENT, $<ctxt>4,
1532                                GEDCOM_MAKE_NULL(val1));
1533                  }
1534                ;
1535
1536 sour_data_subs : /* empty */
1537                | sour_data_subs sour_data_sub
1538                ;
1539
1540 sour_data_sub  : sour_data_even_sect  /* 0:M */
1541                | sour_data_agnc_sect  { OCCUR2(AGNC, 0, 1) }
1542                | note_struc_sub  /* 0:M */
1543                | no_std_sub
1544                ;
1545
1546 sour_data_even_sect : OPEN DELIM TAG_EVEN mand_line_item
1547                       { $<ctxt>$ = start_element(ELT_SOUR_DATA_EVEN,
1548                                                  PARENT, $1, $3, $4,
1549                                                  GEDCOM_MAKE_STRING(val1, $4));
1550                         START(EVEN, $1, $<ctxt>$)
1551                       }
1552                       sour_data_even_subs
1553                       { CHECK0 }
1554                       CLOSE
1555                       { end_element(ELT_SOUR_DATA_EVEN, PARENT,
1556                                     $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1557                       }
1558                     ;
1559
1560 sour_data_even_subs : /* empty */
1561                     | sour_data_even_subs sour_data_even_sub
1562                     ;
1563
1564 sour_data_even_sub  : sour_data_even_date_sect { OCCUR2(DATE, 0, 1) }
1565                     | sour_data_even_plac_sect { OCCUR2(PLAC, 0, 1) }
1566                     | no_std_sub
1567                     ;
1568
1569 sour_data_even_date_sect : OPEN DELIM TAG_DATE mand_line_item
1570                            { struct date_value dv = gedcom_parse_date($4);
1571                              $<ctxt>$
1572                                = start_element(ELT_SOUR_DATA_EVEN_DATE,
1573                                                PARENT, $1, $3, $4,
1574                                                GEDCOM_MAKE_DATE(val1, dv));
1575                              START(DATE, $1, $<ctxt>$)
1576                            }
1577                            no_std_subs
1578                            { CHECK0 }
1579                            CLOSE
1580                            { end_element(ELT_SOUR_DATA_EVEN_DATE, PARENT,
1581                                          $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1582                            }
1583                          ;
1584
1585 sour_data_even_plac_sect : OPEN DELIM TAG_PLAC mand_line_item
1586                            { $<ctxt>$
1587                                = start_element(ELT_SOUR_DATA_EVEN_PLAC,
1588                                                PARENT, $1, $3, $4,
1589                                                GEDCOM_MAKE_STRING(val1, $4));
1590                              START(PLAC, $1, $<ctxt>$)
1591                            }
1592                            no_std_subs
1593                            { CHECK0 }
1594                            CLOSE
1595                            { end_element(ELT_SOUR_DATA_EVEN_PLAC, PARENT,
1596                                          $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1597                            }
1598                          ;
1599
1600 sour_data_agnc_sect : OPEN DELIM TAG_AGNC mand_line_item
1601                       { $<ctxt>$ = start_element(ELT_SOUR_DATA_AGNC,
1602                                                  PARENT, $1, $3, $4,
1603                                                  GEDCOM_MAKE_STRING(val1, $4));
1604                         START(AGNC, $1, $<ctxt>$)
1605                       }
1606                       no_std_subs
1607                       { CHECK0 }
1608                       CLOSE
1609                       { end_element(ELT_SOUR_DATA_AGNC, PARENT,
1610                                     $<ctxt>5, GEDCOM_MAKE_NULL(val1));
1611                       }
1612                     ;
1613
1614 /* SOUR.AUTH */
1615 sour_auth_sect : OPEN DELIM TAG_AUTH mand_line_item
1616                  { $<ctxt>$ = start_element(ELT_SOUR_AUTH,
1617                                             PARENT, $1, $3, $4,
1618                                             GEDCOM_MAKE_STRING(val1, $4));
1619                    reset_buffer(&concat_buffer);
1620                    safe_buf_append(&concat_buffer, $4);
1621                    START(AUTH, $1, $<ctxt>$)
1622                  }
1623                  sour_auth_subs
1624                  { CHECK0 }
1625                  CLOSE
1626                  { char* complete = get_buf_string(&concat_buffer);
1627                    end_element(ELT_SOUR_AUTH, PARENT, $<ctxt>5,
1628                                GEDCOM_MAKE_STRING(val1, complete));
1629                  }
1630                ;
1631
1632 sour_auth_subs : /* empty */
1633                | sour_auth_subs sour_auth_sub
1634                ;
1635
1636 sour_auth_sub  : continuation_sub  /* 0:M */
1637                | no_std_sub
1638                ;
1639
1640 /* SOUR.TITL */
1641 sour_titl_sect : OPEN DELIM TAG_TITL mand_line_item
1642                  { $<ctxt>$ = start_element(ELT_SOUR_TITL,
1643                                             PARENT, $1, $3, $4,
1644                                             GEDCOM_MAKE_STRING(val1, $4));
1645                    reset_buffer(&concat_buffer);
1646                    safe_buf_append(&concat_buffer, $4);
1647                    START(TITL, $1, $<ctxt>$)
1648                  }
1649                  sour_titl_subs
1650                  { CHECK0 }
1651                  CLOSE
1652                  { char* complete = get_buf_string(&concat_buffer);
1653                    end_element(ELT_SOUR_TITL, PARENT, $<ctxt>5,
1654                                GEDCOM_MAKE_STRING(val1, complete));
1655                  }
1656                ;
1657
1658 sour_titl_subs : /* empty */
1659                | sour_titl_subs sour_titl_sub
1660                ;
1661
1662 sour_titl_sub  : continuation_sub  /* 0:M */
1663                | no_std_sub
1664                ;
1665
1666 /* SOUR.ABBR */
1667 sour_abbr_sect : OPEN DELIM TAG_ABBR mand_line_item
1668                  { $<ctxt>$ = start_element(ELT_SOUR_ABBR,
1669                                             PARENT, $1, $3, $4,
1670                                             GEDCOM_MAKE_STRING(val1, $4));
1671                    START(ABBR, $1, $<ctxt>$)
1672                  }
1673                  no_std_subs
1674                  { CHECK0 }
1675                  CLOSE
1676                  { end_element(ELT_SOUR_ABBR, PARENT, $<ctxt>5,
1677                                GEDCOM_MAKE_NULL(val1));
1678                  }
1679                ;
1680
1681 /* SOUR.PUBL */
1682 sour_publ_sect : OPEN DELIM TAG_PUBL mand_line_item
1683                  { $<ctxt>$ = start_element(ELT_SOUR_PUBL,
1684                                             PARENT, $1, $3, $4,
1685                                             GEDCOM_MAKE_STRING(val1, $4));
1686                    reset_buffer(&concat_buffer);
1687                    safe_buf_append(&concat_buffer, $4);
1688                    START(PUBL, $1, $<ctxt>$)
1689                  }
1690                  sour_publ_subs
1691                  { CHECK0 }
1692                  CLOSE
1693                  { char* complete = get_buf_string(&concat_buffer);
1694                    end_element(ELT_SOUR_PUBL, PARENT, $<ctxt>5,
1695                                GEDCOM_MAKE_STRING(val1, complete));
1696                  }
1697                ;
1698
1699 sour_publ_subs : /* empty */
1700                | sour_publ_subs sour_publ_sub
1701                ;
1702
1703 sour_publ_sub  : continuation_sub  /* 0:M */
1704                | no_std_sub
1705                ;
1706
1707 /* SOUR.TEXT */
1708 sour_text_sect : OPEN DELIM TAG_TEXT mand_line_item
1709                  { $<ctxt>$ = start_element(ELT_SOUR_TEXT,
1710                                             PARENT, $1, $3, $4,
1711                                             GEDCOM_MAKE_STRING(val1, $4));
1712                    reset_buffer(&concat_buffer);
1713                    safe_buf_append(&concat_buffer, $4);
1714                    START(TEXT, $1, $<ctxt>$)
1715                  }
1716                  sour_text_subs
1717                  { CHECK0 }
1718                  CLOSE
1719                  { char* complete = get_buf_string(&concat_buffer);
1720                    end_element(ELT_SOUR_TEXT, PARENT, $<ctxt>5,
1721                                GEDCOM_MAKE_STRING(val1, complete));
1722                  }
1723                ;
1724
1725 sour_text_subs : /* empty */
1726                | sour_text_subs sour_text_sub
1727                ;
1728
1729 sour_text_sub  : continuation_sub  /* 0:M */
1730                | no_std_sub
1731                ;
1732
1733 /*********************************************************************/
1734 /**** Submission record                                           ****/
1735 /*********************************************************************/
1736 submis_rec  : OPEN DELIM POINTER DELIM TAG_SUBN
1737               { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1738                                                           XREF_SUBN);
1739                 if (xr == NULL) HANDLE_ERROR;
1740                 $<ctxt>$ = start_record(REC_SUBN,
1741                                         $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1742                                         NULL, GEDCOM_MAKE_NULL(val2));
1743                 START(SUBN, $1, $<ctxt>$) }
1744               subn_subs
1745               { CHECK0 }
1746               CLOSE
1747               { end_record(REC_SUBN, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
1748             ;
1749
1750 subn_subs   : /* empty */
1751             | subn_subs subn_sub
1752             ;
1753
1754 subn_sub    : subn_subm_sect  { OCCUR2(SUBM, 0, 1) }
1755             | subn_famf_sect  { OCCUR2(FAMF, 0, 1) }
1756             | subn_temp_sect  { OCCUR2(TEMP, 0, 1) }
1757             | subn_ance_sect  { OCCUR2(ANCE, 0, 1) }
1758             | subn_desc_sect  { OCCUR2(DESC, 0, 1) }
1759             | subn_ordi_sect  { OCCUR2(ORDI, 0, 1) }
1760             | subn_rin_sect  { OCCUR2(RIN, 0, 1) }
1761             | no_std_sub
1762             ;
1763
1764 /* SUBN.SUBM */
1765 subn_subm_sect : OPEN DELIM TAG_SUBM mand_pointer
1766                  { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
1767                                                              XREF_SUBM);
1768                    if (xr == NULL) HANDLE_ERROR;
1769                    $<ctxt>$ = start_element(ELT_SUBN_SUBM,
1770                                             PARENT, $1, $3, $4,
1771                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
1772                    START(SUBM, $1, $<ctxt>$)
1773                  }
1774                  no_std_subs
1775                  { CHECK0 }
1776                  CLOSE
1777                  { end_element(ELT_SUBN_SUBM, PARENT, $<ctxt>5,
1778                                GEDCOM_MAKE_NULL(val1));
1779                  }
1780                ;
1781
1782 /* SUBN.FAMF */
1783 subn_famf_sect : OPEN DELIM TAG_FAMF mand_line_item
1784                  { $<ctxt>$ = start_element(ELT_SUBN_FAMF,
1785                                             PARENT, $1, $3, $4,
1786                                             GEDCOM_MAKE_STRING(val1, $4));
1787                    START(FAMF, $1, $<ctxt>$)
1788                  }
1789                  no_std_subs
1790                  { CHECK0 }
1791                  CLOSE
1792                  { end_element(ELT_SUBN_FAMF, PARENT, $<ctxt>5,
1793                                GEDCOM_MAKE_NULL(val1));
1794                  }
1795                ;
1796
1797 /* SUBN.TEMP */
1798 subn_temp_sect : OPEN DELIM TAG_TEMP mand_line_item
1799                  { $<ctxt>$ = start_element(ELT_SUBN_TEMP,
1800                                             PARENT, $1, $3, $4,
1801                                             GEDCOM_MAKE_STRING(val1, $4));
1802                    START(TEMP, $1, $<ctxt>$)
1803                  }
1804                  no_std_subs
1805                  { CHECK0 }
1806                  CLOSE
1807                  { end_element(ELT_SUBN_TEMP, PARENT, $<ctxt>5,
1808                                GEDCOM_MAKE_NULL(val1));
1809                  }
1810                ;
1811
1812 /* SUBN.ANCE */
1813 subn_ance_sect : OPEN DELIM TAG_ANCE mand_line_item
1814                  { $<ctxt>$ = start_element(ELT_SUBN_ANCE,
1815                                             PARENT, $1, $3, $4,
1816                                             GEDCOM_MAKE_STRING(val1, $4));
1817                    START(ANCE, $1, $<ctxt>$)
1818                  }
1819                  no_std_subs
1820                  { CHECK0 }
1821                  CLOSE
1822                  { end_element(ELT_SUBN_ANCE, PARENT, $<ctxt>5,
1823                                GEDCOM_MAKE_NULL(val1));
1824                  }
1825                ;
1826
1827 /* SUBN.DESC */
1828 subn_desc_sect : OPEN DELIM TAG_DESC mand_line_item
1829                  { $<ctxt>$ = start_element(ELT_SUBN_DESC,
1830                                             PARENT, $1, $3, $4,
1831                                             GEDCOM_MAKE_STRING(val1, $4));
1832                    START(DESC, $1, $<ctxt>$)
1833                  }
1834                  no_std_subs
1835                  { CHECK0 }
1836                  CLOSE
1837                  { end_element(ELT_SUBN_DESC, PARENT, $<ctxt>5,
1838                                GEDCOM_MAKE_NULL(val1));
1839                  }
1840                ;
1841
1842 /* SUBN.ORDI */
1843 subn_ordi_sect : OPEN DELIM TAG_ORDI mand_line_item
1844                  { $<ctxt>$ = start_element(ELT_SUBN_ORDI,
1845                                             PARENT, $1, $3, $4,
1846                                             GEDCOM_MAKE_STRING(val1, $4));
1847                    START(ORDI, $1, $<ctxt>$)
1848                  }
1849                  no_std_subs
1850                  { CHECK0 }
1851                  CLOSE
1852                  { end_element(ELT_SUBN_ORDI, PARENT, $<ctxt>5,
1853                                GEDCOM_MAKE_NULL(val1));
1854                  }
1855                ;
1856
1857 /* SUBN.RIN */
1858 subn_rin_sect  : OPEN DELIM TAG_RIN mand_line_item
1859                  { $<ctxt>$ = start_element(ELT_SUBN_RIN,
1860                                             PARENT, $1, $3, $4,
1861                                             GEDCOM_MAKE_STRING(val1, $4));
1862                    START(RIN, $1, $<ctxt>$)
1863                  }
1864                  no_std_subs
1865                  { CHECK0 }
1866                  CLOSE
1867                  { end_element(ELT_SUBN_RIN, PARENT, $<ctxt>5,
1868                                GEDCOM_MAKE_NULL(val1));
1869                  }
1870                ;
1871
1872 /*********************************************************************/
1873 /**** Submitter record                                            ****/
1874 /*********************************************************************/
1875 submit_rec : OPEN DELIM POINTER DELIM TAG_SUBM
1876              { struct xref_value *xr = gedcom_parse_xref($3, XREF_DEFINED,
1877                                                          XREF_SUBM);
1878                if (xr == NULL) HANDLE_ERROR;
1879                $<ctxt>$ = start_record(REC_SUBM,
1880                                        $1, GEDCOM_MAKE_XREF_PTR(val1, xr), $5,
1881                                        NULL, GEDCOM_MAKE_NULL(val2));
1882                 START(SUBM, $1, $<ctxt>$) }
1883              subm_subs
1884              { CHECK1(NAME) }
1885              CLOSE
1886              { end_record(REC_SUBM, $<ctxt>6, GEDCOM_MAKE_NULL(val1)); }
1887            ;
1888
1889 subm_subs  : /* empty */
1890            | subm_subs subm_sub
1891            ;
1892
1893 subm_sub   : subm_name_sect  { OCCUR2(NAME, 1, 1) }
1894            | addr_struc_sub  /* 0:1 */
1895            | multim_link_sub  /* 0:M */
1896            | subm_lang_sect  { OCCUR2(LANG, 0, 3) }
1897            | subm_rfn_sect  { OCCUR2(RFN, 0, 1) }
1898            | subm_rin_sect  { OCCUR2(RIN, 0, 1) }
1899            | change_date_sub  /* 0:1 */
1900            | no_std_sub
1901            ;
1902
1903 /* SUBM.NAME */
1904 subm_name_sect : OPEN DELIM TAG_NAME mand_line_item
1905                  { $<ctxt>$ = start_element(ELT_SUBM_NAME,
1906                                             PARENT, $1, $3, $4,
1907                                             GEDCOM_MAKE_STRING(val1, $4));
1908                    START(NAME, $1, $<ctxt>$)
1909                  }
1910                  no_std_subs
1911                  { CHECK0 }
1912                  CLOSE
1913                  { end_element(ELT_SUBM_NAME, PARENT, $<ctxt>5,
1914                                GEDCOM_MAKE_NULL(val1));
1915                  }
1916                ;
1917
1918 /* SUBM.LANG */
1919 subm_lang_sect : OPEN DELIM TAG_LANG mand_line_item
1920                  { $<ctxt>$ = start_element(ELT_SUBM_LANG,
1921                                             PARENT, $1, $3, $4,
1922                                             GEDCOM_MAKE_STRING(val1, $4));
1923                    START(LANG, $1, $<ctxt>$)
1924                  }
1925                  no_std_subs
1926                  { CHECK0 }
1927                  CLOSE
1928                  { end_element(ELT_SUBM_LANG, PARENT, $<ctxt>5,
1929                                GEDCOM_MAKE_NULL(val1));
1930                  }
1931                ;
1932
1933 /* SUBM.RFN */
1934 subm_rfn_sect  : OPEN DELIM TAG_RFN mand_line_item
1935                  { $<ctxt>$ = start_element(ELT_SUBM_RFN,
1936                                             PARENT, $1, $3, $4,
1937                                             GEDCOM_MAKE_STRING(val1, $4));
1938                    START(RFN, $1, $<ctxt>$)
1939                  }
1940                  no_std_subs
1941                  { CHECK0 }
1942                  CLOSE
1943                  { end_element(ELT_SUBM_RFN, PARENT, $<ctxt>5,
1944                                GEDCOM_MAKE_NULL(val1));
1945                  }
1946                ;
1947
1948 /* SUBM.RIN */
1949 subm_rin_sect  : OPEN DELIM TAG_RIN mand_line_item
1950                  { $<ctxt>$ = start_element(ELT_SUBM_RIN,
1951                                             PARENT, $1, $3, $4,
1952                                             GEDCOM_MAKE_STRING(val1, $4));
1953                    START(RIN, $1, $<ctxt>$)
1954                  }
1955                  no_std_subs
1956                  { CHECK0 }
1957                  CLOSE
1958                  { end_element(ELT_SUBM_RIN, PARENT, $<ctxt>5,
1959                                GEDCOM_MAKE_NULL(val1));
1960                  }
1961                ;
1962
1963 /*********************************************************************/
1964 /**** Substructures                                               ****/
1965 /*********************************************************************/
1966
1967 /* ADDRESS STRUCTURE */
1968 addr_struc_sub : addr_sect { OCCUR2(ADDR, 0, 1) }
1969                | phon_sect { OCCUR2(PHON, 0, 3) }
1970                ;
1971
1972 addr_sect   : OPEN DELIM TAG_ADDR mand_line_item
1973               { $<ctxt>$ = start_element(ELT_SUB_ADDR,
1974                                          PARENT, $1, $3, $4,
1975                                          GEDCOM_MAKE_STRING(val1, $4));
1976                 reset_buffer(&concat_buffer);
1977                 safe_buf_append(&concat_buffer, $4);
1978                 START(ADDR, $1, $<ctxt>$)
1979               }
1980               addr_subs
1981               { CHECK0 }
1982               CLOSE
1983               { char* complete = get_buf_string(&concat_buffer);
1984                 end_element(ELT_SUB_ADDR, PARENT, $<ctxt>5,
1985                             GEDCOM_MAKE_STRING(val1, complete));
1986               }
1987             ;
1988
1989 addr_subs   : /* empty */
1990             | addr_subs addr_sub
1991             ;
1992
1993 addr_sub    : addr_cont_sect  /* 0:M */
1994             | addr_adr1_sect  { OCCUR2(ADR1, 0, 1) }
1995             | addr_adr2_sect  { OCCUR2(ADR2, 0, 1) }
1996             | addr_city_sect  { OCCUR2(CITY, 0, 1) }
1997             | addr_stae_sect  { OCCUR2(STAE, 0, 1) }
1998             | addr_post_sect  { OCCUR2(POST, 0, 1) }
1999             | addr_ctry_sect  { OCCUR2(CTRY, 0, 1) }
2000             | no_std_sub
2001             ;
2002
2003 addr_cont_sect : OPEN DELIM TAG_CONT mand_line_item
2004                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_CONT,
2005                                             PARENT, $1, $3, $4,
2006                                             GEDCOM_MAKE_STRING(val1, $4));
2007                    SAFE_BUF_ADDCHAR(&concat_buffer, '\n');
2008                    safe_buf_append(&concat_buffer, $4);
2009                    START(CONT, $1, $<ctxt>$)
2010                  }
2011                  no_std_subs
2012                  { CHECK0 }
2013                  CLOSE
2014                  { end_element(ELT_SUB_ADDR_CONT, PARENT, $<ctxt>5,
2015                                GEDCOM_MAKE_NULL(val1));
2016                  }
2017                ;
2018 addr_adr1_sect : OPEN DELIM TAG_ADR1 mand_line_item
2019                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_ADR1,
2020                                             PARENT, $1, $3, $4,
2021                                             GEDCOM_MAKE_STRING(val1, $4));
2022                    START(ADR1, $1, $<ctxt>$)
2023                  }
2024                  no_std_subs
2025                  { CHECK0 }
2026                  CLOSE
2027                  { end_element(ELT_SUB_ADDR_ADR1, PARENT, $<ctxt>5,
2028                                GEDCOM_MAKE_NULL(val1));
2029                  }
2030                ;
2031 addr_adr2_sect : OPEN DELIM TAG_ADR2 mand_line_item
2032                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_ADR2,
2033                                             PARENT, $1, $3, $4,
2034                                             GEDCOM_MAKE_STRING(val1, $4));
2035                    START(ADR2, $1, $<ctxt>$)
2036                  }
2037                  no_std_subs
2038                  { CHECK0 }
2039                  CLOSE
2040                  { end_element(ELT_SUB_ADDR_ADR2, PARENT, $<ctxt>5,
2041                                GEDCOM_MAKE_NULL(val1));
2042                  }
2043                ;
2044 addr_city_sect : OPEN DELIM TAG_CITY mand_line_item
2045                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_CITY,
2046                                             PARENT, $1, $3, $4,
2047                                             GEDCOM_MAKE_STRING(val1, $4));
2048                    START(CITY, $1, $<ctxt>$)
2049                  }
2050                  no_std_subs
2051                  { CHECK0 }
2052                  CLOSE
2053                  { end_element(ELT_SUB_ADDR_CITY, PARENT, $<ctxt>5,
2054                                GEDCOM_MAKE_NULL(val1));
2055                  }
2056                ;
2057 addr_stae_sect : OPEN DELIM TAG_STAE mand_line_item
2058                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_STAE,
2059                                             PARENT, $1, $3, $4,
2060                                             GEDCOM_MAKE_STRING(val1, $4));
2061                    START(STAE, $1, $<ctxt>$)
2062                  }
2063                  no_std_subs
2064                  { CHECK0 }
2065                  CLOSE
2066                  { end_element(ELT_SUB_ADDR_STAE, PARENT, $<ctxt>5,
2067                                GEDCOM_MAKE_NULL(val1));
2068                  }
2069                ;
2070 addr_post_sect : OPEN DELIM TAG_POST mand_line_item
2071                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_POST,
2072                                             PARENT, $1, $3, $4,
2073                                             GEDCOM_MAKE_STRING(val1, $4));
2074                    START(POST, $1, $<ctxt>$)
2075                  }
2076                  no_std_subs
2077                  { CHECK0 }
2078                  CLOSE
2079                  { end_element(ELT_SUB_ADDR_POST, PARENT, $<ctxt>5,
2080                                GEDCOM_MAKE_NULL(val1));
2081                  }
2082                ;
2083 addr_ctry_sect : OPEN DELIM TAG_CTRY mand_line_item
2084                  { $<ctxt>$ = start_element(ELT_SUB_ADDR_CTRY,
2085                                             PARENT, $1, $3, $4,
2086                                             GEDCOM_MAKE_STRING(val1, $4));
2087                    START(CTRY, $1, $<ctxt>$)
2088                  }
2089                  no_std_subs
2090                  { CHECK0 }
2091                  CLOSE
2092                  { end_element(ELT_SUB_ADDR_CTRY, PARENT, $<ctxt>5,
2093                                GEDCOM_MAKE_NULL(val1));
2094                  }
2095                ;
2096
2097 phon_sect   : OPEN DELIM TAG_PHON mand_line_item
2098               { $<ctxt>$ = start_element(ELT_SUB_PHON,
2099                                          PARENT, $1, $3, $4,
2100                                          GEDCOM_MAKE_STRING(val1, $4));
2101                 START(PHON, $1, $<ctxt>$)
2102               }
2103               no_std_subs
2104               { CHECK0 }
2105               CLOSE
2106               { end_element(ELT_SUB_PHON, PARENT, $<ctxt>5,
2107                             GEDCOM_MAKE_NULL(val1));
2108               }
2109             ;
2110
2111 /* ASSOCIATION STRUCTURE */
2112 assoc_struc_sub : asso_sect /* 0:M */
2113                 ;
2114
2115 asso_sect : OPEN DELIM TAG_ASSO mand_pointer
2116             { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
2117                                                         XREF_ANY);
2118               if (xr == NULL) HANDLE_ERROR;
2119               $<ctxt>$ = start_element(ELT_SUB_ASSO,
2120                                        PARENT, $1, $3, $4,
2121                                        GEDCOM_MAKE_XREF_PTR(val1, xr));
2122               START(ASSO, $1, $<ctxt>$)
2123             }
2124             asso_subs
2125             { CHECK2(TYPE,RELA) }
2126             CLOSE
2127             { end_element(ELT_SUB_ASSO, PARENT, $<ctxt>5,
2128                           GEDCOM_MAKE_NULL(val1));
2129             }
2130           ;
2131
2132 asso_subs : /* empty */
2133           | asso_type_sect  { OCCUR2(TYPE, 1, 1) }
2134           | asso_rela_sect  { OCCUR2(RELA, 1, 1) }
2135           | note_struc_sub
2136           | source_cit_sub
2137           | no_std_sub
2138           ;
2139
2140 asso_type_sect : OPEN DELIM TAG_TYPE mand_line_item
2141                  { $<ctxt>$ = start_element(ELT_SUB_ASSO_TYPE,
2142                                             PARENT, $1, $3, $4,
2143                                             GEDCOM_MAKE_STRING(val1, $4));
2144                    START(TYPE, $1, $<ctxt>$)
2145                  }
2146                  no_std_subs
2147                  { CHECK0 }
2148                  CLOSE
2149                  { end_element(ELT_SUB_ASSO_TYPE, PARENT, $<ctxt>5,
2150                                GEDCOM_MAKE_NULL(val1));
2151                  }
2152                ;
2153
2154 asso_rela_sect : OPEN DELIM TAG_RELA mand_line_item
2155                  { $<ctxt>$ = start_element(ELT_SUB_ASSO_RELA,
2156                                             PARENT, $1, $3, $4,
2157                                             GEDCOM_MAKE_STRING(val1, $4));
2158                    START(RELA, $1, $<ctxt>$)
2159                  }
2160                  no_std_subs
2161                  { CHECK0 }
2162                  CLOSE
2163                  { end_element(ELT_SUB_ASSO_RELA, PARENT, $<ctxt>5,
2164                                GEDCOM_MAKE_NULL(val1));
2165                  }
2166                ;
2167
2168 /* CHANGE DATE */
2169 change_date_sub : change_date_chan_sect  { OCCUR2(CHAN, 0, 1) }
2170                 ;
2171
2172 change_date_chan_sect : OPEN DELIM TAG_CHAN
2173                         { $<ctxt>$ = start_element(ELT_SUB_CHAN,
2174                                                    PARENT, $1, $3, NULL,
2175                                                    GEDCOM_MAKE_NULL(val1));
2176                           START(CHAN, $1, $<ctxt>$)
2177                         }
2178                         change_date_chan_subs
2179                         { CHECK1(DATE) }
2180                         CLOSE
2181                         { end_element(ELT_SUB_CHAN, PARENT, $<ctxt>4,
2182                                       GEDCOM_MAKE_NULL(val1));
2183                         }
2184                       ;
2185
2186 change_date_chan_subs : /* empty */
2187                       | change_date_chan_subs change_date_chan_sub
2188                       ;
2189
2190 change_date_chan_sub  : change_date_date_sect  { OCCUR2(DATE, 1, 1) }
2191                       | note_struc_sub
2192                       | no_std_sub
2193                       ;
2194
2195 change_date_date_sect : OPEN DELIM TAG_DATE mand_line_item
2196                         { struct date_value dv = gedcom_parse_date($4);
2197                           $<ctxt>$ = start_element(ELT_SUB_CHAN_DATE,
2198                                                    PARENT, $1, $3, $4,
2199                                                    GEDCOM_MAKE_DATE(val1, dv));
2200                           START(DATE, $1, $<ctxt>$) }
2201                         change_date_date_subs
2202                         { CHECK0 }
2203                         CLOSE
2204                         { end_element(ELT_SUB_CHAN_DATE, PARENT, $<ctxt>5,
2205                                       GEDCOM_MAKE_NULL(val1));
2206                         }
2207                       ;
2208
2209 change_date_date_subs : /* empty */
2210                       | change_date_date_subs change_date_date_sub
2211                       ;
2212
2213 change_date_date_sub : change_date_date_time_sect  { OCCUR2(TIME, 0, 1) }
2214                      | no_std_sub
2215                      ;
2216
2217 change_date_date_time_sect : OPEN DELIM TAG_TIME mand_line_item
2218                              { $<ctxt>$
2219                                  = start_element(ELT_SUB_CHAN_TIME,
2220                                                  PARENT, $1, $3, $4,
2221                                                  GEDCOM_MAKE_STRING(val1, $4));
2222                                START(TIME, $1, $<ctxt>$)
2223                              }
2224                              no_std_subs
2225                              { CHECK0 }
2226                              CLOSE
2227                              { end_element(ELT_SUB_CHAN_TIME, PARENT, $<ctxt>5,
2228                                            GEDCOM_MAKE_NULL(val1));
2229                              }
2230                            ;
2231
2232 /* CHILD TO FAMILY LINK */
2233 chi_fam_link_sub : famc_sect  /* 0:M */
2234                  ;
2235
2236 famc_sect : OPEN DELIM TAG_FAMC mand_pointer
2237             { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
2238                                                           XREF_FAM);
2239               if (xr == NULL) HANDLE_ERROR;
2240               $<ctxt>$ = start_element(ELT_SUB_FAMC,
2241                                        PARENT, $1, $3, $4,
2242                                        GEDCOM_MAKE_XREF_PTR(val1, xr));
2243               START(FAMC, $1, $<ctxt>$)
2244             }
2245             famc_subs
2246             { CHECK0 }
2247             CLOSE
2248             { end_element(ELT_SUB_FAMC, PARENT, $<ctxt>5,
2249                           GEDCOM_MAKE_NULL(val1));
2250             }
2251           ;
2252
2253 famc_subs : /* empty */
2254           | famc_subs famc_sub
2255           ;
2256
2257 famc_sub  : famc_pedi_sect  /* 0:M */
2258           | note_struc_sub
2259           | no_std_sub
2260           ;
2261
2262 famc_pedi_sect : OPEN DELIM TAG_PEDI mand_line_item
2263                  { $<ctxt>$ = start_element(ELT_SUB_FAMC_PEDI,
2264                                             PARENT, $1, $3, $4,
2265                                             GEDCOM_MAKE_STRING(val1, $4));
2266                    START(PEDI, $1, $<ctxt>$)
2267                  }
2268                  no_std_subs
2269                  { CHECK0 }
2270                  CLOSE
2271                  { end_element(ELT_SUB_FAMC_PEDI, PARENT, $<ctxt>5,
2272                                GEDCOM_MAKE_NULL(val1));
2273                  }
2274                ;
2275
2276 /* CONTINUATION SUBSECTIONS */
2277 continuation_sub : cont_sect  /* 0:M */
2278                  | conc_sect  /* 0:M */
2279                  ;
2280
2281 cont_sect : OPEN DELIM TAG_CONT mand_line_item
2282             { $<ctxt>$ = start_element(ELT_SUB_CONT,
2283                                        PARENT, $1, $3, $4,
2284                                        GEDCOM_MAKE_STRING(val1, $4));
2285               SAFE_BUF_ADDCHAR(&concat_buffer, '\n');
2286               safe_buf_append(&concat_buffer, $4);
2287               START(CONT, $1, $<ctxt>$)
2288             }
2289             no_std_subs
2290             { CHECK0 }
2291             CLOSE
2292             { end_element(ELT_SUB_CONT, PARENT, $<ctxt>5,
2293                           GEDCOM_MAKE_NULL(val1));
2294             }
2295           ;
2296
2297 conc_sect : OPEN DELIM TAG_CONC mand_line_item
2298             { $<ctxt>$ = start_element(ELT_SUB_CONC,
2299                                        PARENT, $1, $3, $4,
2300                                        GEDCOM_MAKE_STRING(val1, $4));
2301               safe_buf_append(&concat_buffer, $4);
2302               START(CONC, $1, $<ctxt>$)
2303             }
2304             no_std_subs
2305             { CHECK0 }
2306             CLOSE
2307             { end_element(ELT_SUB_CONC, PARENT, $<ctxt>5,
2308                           GEDCOM_MAKE_NULL(val1));
2309             }
2310           ;
2311
2312 /* EVENT DETAIL */
2313 event_detail_sub : event_detail_type_sect  { OCCUR2(TYPE, 0, 1) }
2314                  | event_detail_date_sect  { OCCUR2(DATE, 0, 1) }
2315                  | place_struc_sub
2316                  | addr_struc_sub
2317                  | event_detail_age_sect  { OCCUR2(AGE, 0, 1) }
2318                  | event_detail_agnc_sect  { OCCUR2(AGNC, 0, 1) }
2319                  | event_detail_caus_sect  { OCCUR2(CAUS, 0, 1) }
2320                  | source_cit_sub
2321                  | multim_link_sub
2322                  | note_struc_sub
2323                  ;
2324
2325 event_detail_type_sect : OPEN DELIM TAG_TYPE mand_line_item
2326                          { $<ctxt>$
2327                              = start_element(ELT_SUB_EVT_TYPE,
2328                                              PARENT, $1, $3, $4,
2329                                              GEDCOM_MAKE_STRING(val1, $4));
2330                            START(TYPE, $1, $<ctxt>$)
2331                          }
2332                          no_std_subs
2333                          { CHECK0 }
2334                          CLOSE
2335                          { end_element(ELT_SUB_EVT_TYPE, PARENT, $<ctxt>5,
2336                                        GEDCOM_MAKE_NULL(val1));
2337                          }
2338                        ;
2339 event_detail_date_sect : OPEN DELIM TAG_DATE mand_line_item
2340                          { struct date_value dv = gedcom_parse_date($4);
2341                            $<ctxt>$
2342                              = start_element(ELT_SUB_EVT_DATE,
2343                                              PARENT, $1, $3, $4,
2344                                              GEDCOM_MAKE_DATE(val1, dv));
2345                            START(DATE, $1, $<ctxt>$)
2346                          }
2347                          no_std_subs
2348                          { CHECK0 }
2349                          CLOSE
2350                          { end_element(ELT_SUB_EVT_DATE, PARENT, $<ctxt>5,
2351                                        GEDCOM_MAKE_NULL(val1));
2352                          }
2353                        ;
2354 event_detail_age_sect  : OPEN DELIM TAG_AGE mand_line_item
2355                          { struct age_value age = gedcom_parse_age($4);
2356                            $<ctxt>$
2357                              = start_element(ELT_SUB_EVT_AGE,
2358                                              PARENT, $1, $3, $4,
2359                                              GEDCOM_MAKE_AGE(val1, age));
2360                            START(AGE, $1, $<ctxt>$)
2361                          }
2362                          no_std_subs
2363                          { CHECK0 }
2364                          CLOSE
2365                          { end_element(ELT_SUB_EVT_AGE, PARENT, $<ctxt>5,
2366                                        GEDCOM_MAKE_NULL(val1));
2367                          }
2368                        ;
2369 event_detail_agnc_sect : OPEN DELIM TAG_AGNC mand_line_item
2370                          { $<ctxt>$
2371                              = start_element(ELT_SUB_EVT_AGNC,
2372                                              PARENT, $1, $3, $4,
2373                                              GEDCOM_MAKE_STRING(val1, $4));
2374                            START(AGNC, $1, $<ctxt>$)
2375                          }
2376                          no_std_subs
2377                          { CHECK0 }
2378                          CLOSE
2379                          { end_element(ELT_SUB_EVT_AGNC, PARENT, $<ctxt>5,
2380                                        GEDCOM_MAKE_NULL(val1));
2381                          }
2382                        ;
2383 event_detail_caus_sect : OPEN DELIM TAG_CAUS mand_line_item
2384                          { $<ctxt>$
2385                              = start_element(ELT_SUB_EVT_CAUS,
2386                                              PARENT, $1, $3, $4,
2387                                              GEDCOM_MAKE_STRING(val1, $4));
2388                            START(CAUS, $1, $<ctxt>$)
2389                          }
2390                          no_std_subs
2391                          { CHECK0 }
2392                          CLOSE
2393                          { end_element(ELT_SUB_EVT_CAUS, PARENT, $<ctxt>5,
2394                                        GEDCOM_MAKE_NULL(val1));
2395                          }
2396                        ;
2397
2398 /* FAMILY EVENT STRUCTURE */
2399 fam_event_struc_sub : fam_event_sect
2400                     | fam_gen_even_sect  /* 0:M */
2401                     ;
2402
2403 fam_event_sect : OPEN DELIM fam_event_tag opt_value
2404                  { $<ctxt>$
2405                      = start_element(ELT_SUB_FAM_EVT,
2406                                      PARENT, $1, $3, $4,
2407                                      GEDCOM_MAKE_NULL_OR_STRING(val1, $4));
2408                    START2($1, $<ctxt>$);
2409                  }
2410                  fam_event_subs
2411                  { CHECK0 }
2412                  CLOSE
2413                  { end_element(ELT_SUB_FAM_EVT, PARENT, $<ctxt>5,
2414                                GEDCOM_MAKE_NULL(val1));
2415                  }
2416                ;
2417
2418 fam_event_tag : TAG_ANUL { $$ = $1; START1(ANUL) }
2419               | TAG_CENS { $$ = $1; START1(CENS) }
2420               | TAG_DIV { $$ = $1; START1(DIV) }
2421               | TAG_DIVF { $$ = $1; START1(DIVF) }
2422               | TAG_ENGA { $$ = $1; START1(ENGA) }
2423               | TAG_MARR { $$ = $1; START1(MARR) }
2424               | TAG_MARB { $$ = $1; START1(MARB) }
2425               | TAG_MARC { $$ = $1; START1(MARC) }
2426               | TAG_MARL { $$ = $1; START1(MARL) }
2427               | TAG_MARS { $$ = $1; START1(MARS) }
2428               ;
2429
2430 fam_event_subs : /* empty */
2431                | fam_event_subs fam_event_sub
2432                ;
2433
2434 fam_event_sub : event_detail_sub
2435               | fam_even_husb_sect  { OCCUR2(HUSB, 0, 1) }
2436               | fam_even_wife_sect  { OCCUR2(WIFE, 0, 1) }
2437               | no_std_sub
2438               ;
2439
2440 fam_even_husb_sect : OPEN DELIM TAG_HUSB
2441                      { $<ctxt>$ = start_element(ELT_SUB_FAM_EVT_HUSB,
2442                                                 PARENT, $1, $3, NULL,
2443                                                 GEDCOM_MAKE_NULL(val1));
2444                        START(HUSB, $1, $<ctxt>$)
2445                      }
2446                      fam_even_husb_subs
2447                      { CHECK1(AGE) }
2448                      CLOSE
2449                      { end_element(ELT_SUB_FAM_EVT_HUSB, PARENT, $<ctxt>4,
2450                                    GEDCOM_MAKE_NULL(val1));
2451                      }
2452                    ;
2453
2454 fam_even_husb_subs : /* empty */
2455                    | fam_even_husb_subs fam_even_husb_sub
2456                    ;
2457
2458 fam_even_husb_sub : fam_even_age_sect  { OCCUR2(AGE, 1, 1) }
2459                   | no_std_sub
2460                   ;
2461
2462 fam_even_age_sect : OPEN DELIM TAG_AGE mand_line_item
2463                     { struct age_value age = gedcom_parse_age($4);
2464                       $<ctxt>$ = start_element(ELT_SUB_FAM_EVT_AGE,
2465                                                PARENT, $1, $3, $4,
2466                                                GEDCOM_MAKE_AGE(val1, age));
2467                       START(AGE, $1, $<ctxt>$)
2468                     }
2469                     no_std_subs
2470                     { CHECK0 }
2471                     CLOSE
2472                     { end_element(ELT_SUB_FAM_EVT_AGE, PARENT, $<ctxt>5,
2473                                   GEDCOM_MAKE_NULL(val1));
2474                     }
2475                   ;
2476
2477 fam_even_wife_sect : OPEN DELIM TAG_WIFE
2478                      { $<ctxt>$ = start_element(ELT_SUB_FAM_EVT_WIFE,
2479                                                 PARENT, $1, $3, NULL,
2480                                                 GEDCOM_MAKE_NULL(val1));
2481                        START(WIFE, $1, $<ctxt>$)
2482                      }
2483                      fam_even_husb_subs
2484                      { CHECK1(AGE) }
2485                      CLOSE
2486                      { end_element(ELT_SUB_FAM_EVT_WIFE, PARENT, $<ctxt>4,
2487                                    GEDCOM_MAKE_NULL(val1));
2488                      }
2489                    ;
2490
2491 fam_gen_even_sect : OPEN DELIM TAG_EVEN
2492                     { $<ctxt>$ = start_element(ELT_SUB_FAM_EVT_EVEN,
2493                                                 PARENT, $1, $3, NULL,
2494                                                 GEDCOM_MAKE_NULL(val1));
2495                        START(EVEN, $1, $<ctxt>$)
2496                     }
2497                     fam_gen_even_subs
2498                     { CHECK0 }
2499                     CLOSE
2500                     { end_element(ELT_SUB_FAM_EVT_EVEN, PARENT, $<ctxt>4,
2501                                   GEDCOM_MAKE_NULL(val1));
2502                     }
2503                   ;
2504
2505 fam_gen_even_subs : /* empty */
2506                   | fam_gen_even_subs fam_gen_even_sub
2507                   ;
2508
2509 fam_gen_even_sub : event_detail_sub
2510                  | fam_even_husb_sect  { OCCUR2(HUSB, 0, 1) }
2511                  | fam_even_wife_sect  { OCCUR2(WIFE, 0, 1) }
2512                  | no_std_sub
2513                  ;
2514
2515 /* IDENTIFICATION STRUCTURE */
2516 ident_struc_sub : ident_refn_sect  /* 0:M */
2517                 | ident_rin_sect  { OCCUR2(RIN, 0, 1) }
2518                 ;
2519
2520 ident_refn_sect : OPEN DELIM TAG_REFN mand_line_item
2521                   { $<ctxt>$ = start_element(ELT_SUB_IDENT_REFN,
2522                                              PARENT, $1, $3, $4,
2523                                              GEDCOM_MAKE_STRING(val1, $4));
2524                     START(REFN, $1, $<ctxt>$)
2525                   }
2526                   ident_refn_subs
2527                   { CHECK0 }
2528                   CLOSE
2529                   { end_element(ELT_SUB_IDENT_REFN, PARENT, $<ctxt>5,
2530                                 GEDCOM_MAKE_NULL(val1));
2531                   }
2532                 ;
2533
2534 ident_refn_subs : /* empty */
2535                 | ident_refn_subs ident_refn_sub
2536                 ;
2537
2538 ident_refn_sub  : ident_refn_type_sect  { OCCUR2(TYPE, 0, 1) }
2539                 | no_std_sub
2540                 ;
2541
2542 ident_refn_type_sect : OPEN DELIM TAG_TYPE mand_line_item
2543                        { $<ctxt>$
2544                            = start_element(ELT_SUB_IDENT_REFN_TYPE,
2545                                            PARENT, $1, $3, $4,
2546                                            GEDCOM_MAKE_STRING(val1, $4));
2547                          START(TYPE, $1, $<ctxt>$)
2548                        }
2549                        no_std_subs
2550                        { CHECK0 }
2551                        CLOSE
2552                        { end_element(ELT_SUB_IDENT_REFN_TYPE, PARENT, $<ctxt>5,
2553                                      GEDCOM_MAKE_NULL(val1));
2554                        }
2555                      ;
2556
2557 ident_rin_sect  : OPEN DELIM TAG_RIN mand_line_item
2558                   { $<ctxt>$ = start_element(ELT_SUB_IDENT_RIN,
2559                                              PARENT, $1, $3, $4,
2560                                              GEDCOM_MAKE_STRING(val1, $4));
2561                     START(RIN, $1, $<ctxt>$)
2562                   }
2563                   no_std_subs
2564                   { CHECK0 }
2565                   CLOSE
2566                   { end_element(ELT_SUB_IDENT_RIN, PARENT, $<ctxt>5,
2567                                 GEDCOM_MAKE_NULL(val1));
2568                   }
2569                 ;
2570
2571 /* INDIVIDUAL ATTRIBUTE STRUCTURE */
2572 indiv_attr_struc_sub : indiv_attr_sect   /* 0:M */
2573                      | indiv_resi_sect  /* 0:M */
2574                      ;
2575
2576 indiv_attr_sect : OPEN DELIM indiv_attr_tag mand_line_item
2577                   { $<ctxt>$ = start_element(ELT_SUB_INDIV_ATTR,
2578                                              PARENT, $1, $3, $4,
2579                                              GEDCOM_MAKE_STRING(val1, $4));
2580                     START2($1, $<ctxt>$);
2581                   }
2582                   indiv_attr_event_subs
2583                   { CHECK0 }
2584                   CLOSE
2585                   { end_element(ELT_SUB_INDIV_ATTR, PARENT, $<ctxt>5,
2586                                 GEDCOM_MAKE_NULL(val1));
2587                   }
2588                 ;
2589
2590 indiv_attr_tag  : TAG_CAST { $$ = $1; START1(CAST) }
2591                 | TAG_DSCR { $$ = $1; START1(DSCR) }
2592                 | TAG_EDUC { $$ = $1; START1(EDUC) }
2593                 | TAG_IDNO { $$ = $1; START1(IDNO) }
2594                 | TAG_NATI { $$ = $1; START1(NATI) }
2595                 | TAG_NCHI { $$ = $1; START1(NCHI) }
2596                 | TAG_NMR  { $$ = $1; START1(NMR) }
2597                 | TAG_OCCU { $$ = $1; START1(OCCU) }
2598                 | TAG_PROP { $$ = $1; START1(PROP) }
2599                 | TAG_RELI { $$ = $1; START1(RELI) }
2600                 | TAG_SSN  { $$ = $1; START1(SSN) }
2601                 | TAG_TITL { $$ = $1; START1(TITL) }
2602                 ;
2603
2604 indiv_resi_sect : OPEN DELIM TAG_RESI
2605                   { $<ctxt>$ = start_element(ELT_SUB_INDIV_RESI,
2606                                              PARENT, $1, $3, NULL,
2607                                              GEDCOM_MAKE_NULL(val1));
2608                     START(RESI, $1, $<ctxt>$)
2609                   }
2610                   indiv_attr_event_subs
2611                   { CHECK0 }
2612                   CLOSE
2613                   { end_element(ELT_SUB_INDIV_RESI, PARENT, $<ctxt>4,
2614                                 GEDCOM_MAKE_NULL(val1));
2615                   }
2616                 ;
2617
2618 indiv_attr_event_subs : /* empty */
2619                       | indiv_attr_event_subs indiv_attr_event_sub
2620                       ;
2621
2622 indiv_attr_event_sub  : event_detail_sub
2623                       | no_std_sub
2624                       ;
2625
2626 /* INDIVIDUAL EVENT STRUCTURE */
2627 indiv_even_struc_sub : indiv_birt_sect
2628                      | indiv_gen_sect
2629                      | indiv_adop_sect  /* 0:M */
2630                      | indiv_even_sect  /* 0:M */
2631                      ;
2632
2633 indiv_birt_sect : OPEN DELIM indiv_birt_tag opt_value
2634                   { $<ctxt>$
2635                       = start_element(ELT_SUB_INDIV_BIRT,
2636                                       PARENT, $1, $3, $4,
2637                                       GEDCOM_MAKE_NULL_OR_STRING(val1, $4));
2638                     START2($1, $<ctxt>$);
2639                   }
2640                   indiv_birt_subs
2641                   { CHECK0 }
2642                   CLOSE
2643                   { end_element(ELT_SUB_INDIV_BIRT, PARENT, $<ctxt>5,
2644                                 GEDCOM_MAKE_NULL(val1));
2645                   }
2646                 ;
2647
2648 indiv_birt_tag  : TAG_BIRT { $$ = $1; START1(BIRT) }
2649                 | TAG_CHR { $$ = $1; START1(CHR) }
2650                 ;
2651
2652 indiv_birt_subs : /* empty */
2653                 | indiv_birt_subs indiv_birt_sub
2654                 ;
2655
2656 indiv_birt_sub  : event_detail_sub
2657                 | indiv_birt_famc_sect  { OCCUR2(FAMC,0, 1) }
2658                 | no_std_sub
2659                 ;
2660
2661 indiv_birt_famc_sect : OPEN DELIM TAG_FAMC mand_pointer
2662                        { struct xref_value *xr = gedcom_parse_xref($4,
2663                                                                    XREF_USED,
2664                                                                    XREF_FAM);
2665                          if (xr == NULL) HANDLE_ERROR;
2666                          $<ctxt>$
2667                            = start_element(ELT_SUB_INDIV_BIRT_FAMC,
2668                                            PARENT, $1, $3, $4,
2669                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
2670                          START(FAMC, $1, $<ctxt>$)
2671                        }
2672                        no_std_subs
2673                        { CHECK0 }
2674                        CLOSE
2675                        { end_element(ELT_SUB_INDIV_BIRT_FAMC, PARENT, $<ctxt>5,
2676                                      GEDCOM_MAKE_NULL(val1));
2677                        }
2678                      ;
2679
2680 indiv_gen_sect  : OPEN DELIM indiv_gen_tag opt_value
2681                   { $<ctxt>$
2682                       = start_element(ELT_SUB_INDIV_GEN,
2683                                       PARENT, $1, $3, $4,
2684                                       GEDCOM_MAKE_NULL_OR_STRING(val1, $4));
2685                     START2($1, $<ctxt>$);
2686                   }
2687                   indiv_gen_subs
2688                   { CHECK0 }
2689                   CLOSE
2690                   { end_element(ELT_SUB_INDIV_GEN, PARENT, $<ctxt>5,
2691                                 GEDCOM_MAKE_NULL(val1));
2692                   }
2693                 ;
2694
2695 indiv_gen_tag   : TAG_DEAT { $$ = $1; START1(DEAT) }
2696                 | TAG_BURI { $$ = $1; START1(BURI) }
2697                 | TAG_CREM { $$ = $1; START1(CREM) }
2698                 | TAG_BAPM { $$ = $1; START1(BAPM) }
2699                 | TAG_BARM { $$ = $1; START1(BARM) }
2700                 | TAG_BASM { $$ = $1; START1(BASM) }
2701                 | TAG_BLES { $$ = $1; START1(BLES) }
2702                 | TAG_CHRA { $$ = $1; START1(CHRA) }
2703                 | TAG_CONF { $$ = $1; START1(CONF) }
2704                 | TAG_FCOM { $$ = $1; START1(FCOM) }
2705                 | TAG_ORDN { $$ = $1; START1(ORDN) }
2706                 | TAG_NATU { $$ = $1; START1(NATU) }
2707                 | TAG_EMIG { $$ = $1; START1(EMIG) }
2708                 | TAG_IMMI { $$ = $1; START1(IMMI) }
2709                 | TAG_CENS { $$ = $1; START1(CENS) }
2710                 | TAG_PROB { $$ = $1; START1(PROB) }
2711                 | TAG_WILL { $$ = $1; START1(WILL) }
2712                 | TAG_GRAD { $$ = $1; START1(GRAD) }
2713                 | TAG_RETI { $$ = $1; START1(RETI) }
2714                 ;
2715
2716 indiv_gen_subs  : /* empty */
2717                 | indiv_gen_subs indiv_gen_sub
2718                 ;
2719
2720 indiv_gen_sub   : event_detail_sub
2721                 | no_std_sub
2722                 ;
2723
2724 indiv_adop_sect : OPEN DELIM TAG_ADOP opt_value
2725                   { $<ctxt>$
2726                       = start_element(ELT_SUB_INDIV_ADOP,
2727                                       PARENT, $1, $3, $4,
2728                                       GEDCOM_MAKE_NULL_OR_STRING(val1, $4));
2729                     START(ADOP, $1, $<ctxt>$) }
2730                   indiv_adop_subs
2731                   { CHECK0 }
2732                   CLOSE
2733                   { end_element(ELT_SUB_INDIV_ADOP, PARENT, $<ctxt>5,
2734                                 GEDCOM_MAKE_NULL(val1));
2735                   }
2736                 ;
2737
2738 indiv_adop_subs : /* empty */
2739                 | indiv_adop_subs indiv_adop_sub
2740                 ;
2741
2742 indiv_adop_sub  : event_detail_sub
2743                 | indiv_adop_famc_sect  { OCCUR2(FAMC,0, 1) }
2744                 | no_std_sub
2745                 ;
2746
2747 indiv_adop_famc_sect : OPEN DELIM TAG_FAMC mand_pointer
2748                        { struct xref_value *xr = gedcom_parse_xref($4,
2749                                                                    XREF_USED,
2750                                                                    XREF_FAM);
2751                          if (xr == NULL) HANDLE_ERROR;
2752                          $<ctxt>$
2753                            = start_element(ELT_SUB_INDIV_ADOP_FAMC,
2754                                            PARENT, $1, $3, $4,
2755                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
2756                          START(FAMC, $1, $<ctxt>$) }
2757                        indiv_adop_famc_subs
2758                        { CHECK0 }
2759                        CLOSE
2760                        { end_element(ELT_SUB_INDIV_ADOP_FAMC, PARENT, $<ctxt>5,
2761                                      GEDCOM_MAKE_NULL(val1));
2762                        }
2763                      ;
2764
2765 indiv_adop_famc_subs : /* empty */
2766                      | indiv_adop_famc_subs indiv_adop_famc_sub
2767                      ;
2768
2769 indiv_adop_famc_sub  : indiv_adop_famc_adop_sect  { OCCUR2(ADOP,0, 1) }
2770                      | no_std_sub
2771                      ;
2772
2773 indiv_adop_famc_adop_sect : OPEN DELIM TAG_ADOP mand_line_item
2774                             { $<ctxt>$
2775                                 = start_element(ELT_SUB_INDIV_ADOP_FAMC_ADOP,
2776                                                 PARENT, $1, $3, $4,
2777                                                 GEDCOM_MAKE_STRING(val1, $4));
2778                               START(ADOP, $1, $<ctxt>$) }
2779                             no_std_subs
2780                             { CHECK0 }
2781                             CLOSE
2782                             { end_element(ELT_SUB_INDIV_ADOP_FAMC_ADOP,
2783                                           PARENT, $<ctxt>5,
2784                                           GEDCOM_MAKE_NULL(val1));
2785                             }
2786                           ;
2787
2788 indiv_even_sect : OPEN DELIM TAG_EVEN
2789                   { $<ctxt>$ = start_element(ELT_SUB_INDIV_EVEN,
2790                                              PARENT, $1, $3, NULL,
2791                                              GEDCOM_MAKE_NULL(val1));
2792                     START(EVEN, $1, $<ctxt>$) }
2793                   indiv_gen_subs
2794                   { CHECK0 }
2795                   CLOSE
2796                   { end_element(ELT_SUB_INDIV_EVEN, PARENT, $<ctxt>4,
2797                                 GEDCOM_MAKE_NULL(val1));
2798                   }
2799                 ;
2800
2801 /* LDS INDIVIDUAL ORDINANCE */
2802 lds_indiv_ord_sub : lio_bapl_sect  /* 0:M */
2803                   | lio_slgc_sect  /* 0:M */
2804                   ;
2805
2806 lio_bapl_sect : OPEN DELIM lio_bapl_tag
2807                 { $<ctxt>$ = start_element(ELT_SUB_LIO_BAPL,
2808                                            PARENT, $1, $3, NULL,
2809                                            GEDCOM_MAKE_NULL(val1));
2810                   START2($1, $<ctxt>$);
2811                 }
2812                 lio_bapl_subs
2813                 { CHECK0 }
2814                 CLOSE
2815                 { end_element(ELT_SUB_LIO_BAPL, PARENT, $<ctxt>4,
2816                               GEDCOM_MAKE_NULL(val1));
2817                 }
2818               ;
2819
2820 lio_bapl_tag  : TAG_BAPL { $$ = $1; START1(BAPL) }
2821               | TAG_CONL { $$ = $1; START1(CONL) }
2822               | TAG_ENDL { $$ = $1; START1(ENDL) }
2823               ;
2824
2825 lio_bapl_subs : /* empty */
2826               | lio_bapl_subs lio_bapl_sub
2827               ;
2828
2829 lio_bapl_sub  : lio_bapl_stat_sect  { OCCUR2(STAT, 0, 1) }
2830               | lio_bapl_date_sect  { OCCUR2(DATE, 0, 1) }
2831               | lio_bapl_temp_sect  { OCCUR2(TEMP, 0, 1) }
2832               | lio_bapl_plac_sect  { OCCUR2(PLAC, 0, 1) }
2833               | source_cit_sub
2834               | note_struc_sub
2835               | no_std_sub
2836               ;
2837
2838 lio_bapl_stat_sect : OPEN DELIM TAG_STAT mand_line_item
2839                      { $<ctxt>$ = start_element(ELT_SUB_LIO_BAPL_STAT,
2840                                                 PARENT, $1, $3, $4,
2841                                                 GEDCOM_MAKE_STRING(val1, $4));
2842                        START(STAT, $1, $<ctxt>$)
2843                      }
2844                      no_std_subs
2845                      { CHECK0 }
2846                      CLOSE
2847                      { end_element(ELT_SUB_LIO_BAPL_STAT, PARENT, $<ctxt>5,
2848                                    GEDCOM_MAKE_NULL(val1));
2849                      }
2850                    ;
2851 lio_bapl_date_sect : OPEN DELIM TAG_DATE mand_line_item
2852                      { struct date_value dv = gedcom_parse_date($4);
2853                        $<ctxt>$ = start_element(ELT_SUB_LIO_BAPL_DATE,
2854                                                 PARENT, $1, $3, $4,
2855                                                 GEDCOM_MAKE_DATE(val1, dv));
2856                        START(DATE, $1, $<ctxt>$)
2857                      }
2858                      no_std_subs
2859                      { CHECK0 }
2860                      CLOSE
2861                      { end_element(ELT_SUB_LIO_BAPL_DATE, PARENT, $<ctxt>5,
2862                                    GEDCOM_MAKE_NULL(val1));
2863                      }
2864                    ;
2865 lio_bapl_temp_sect : OPEN DELIM TAG_TEMP mand_line_item
2866                      { $<ctxt>$ = start_element(ELT_SUB_LIO_BAPL_TEMP,
2867                                                 PARENT, $1, $3, $4,
2868                                                 GEDCOM_MAKE_STRING(val1, $4));
2869                        START(TEMP, $1, $<ctxt>$)
2870                      }
2871                      no_std_subs
2872                      { CHECK0 }
2873                      CLOSE
2874                      { end_element(ELT_SUB_LIO_BAPL_TEMP, PARENT, $<ctxt>5,
2875                                    GEDCOM_MAKE_NULL(val1));
2876                      }
2877                    ;
2878 lio_bapl_plac_sect : OPEN DELIM TAG_PLAC mand_line_item
2879                      { $<ctxt>$ = start_element(ELT_SUB_LIO_BAPL_PLAC,
2880                                                 PARENT, $1, $3, $4,
2881                                                 GEDCOM_MAKE_STRING(val1, $4));
2882                        START(PLAC, $1, $<ctxt>$)
2883                      }
2884                      no_std_subs
2885                      { CHECK0 }
2886                      CLOSE
2887                      { end_element(ELT_SUB_LIO_BAPL_PLAC, PARENT, $<ctxt>5,
2888                                    GEDCOM_MAKE_NULL(val1));
2889                      }
2890                    ;
2891
2892 lio_slgc_sect : OPEN DELIM TAG_SLGC
2893                 { $<ctxt>$ = start_element(ELT_SUB_LIO_SLGC,
2894                                            PARENT, $1, $3, NULL,
2895                                            GEDCOM_MAKE_NULL(val1));
2896                   START(SLGC, $1, $<ctxt>$)
2897                 }
2898                 lio_slgc_subs
2899                 { if (compat_mode(C_NO_SLGC_FAMC) && ! CHK_COND(FAMC))
2900                     compat_generate_slgc_famc_link($<ctxt>4);
2901                   else CHK(FAMC);
2902                   CHECK0;
2903                 }
2904                 CLOSE
2905                 { end_element(ELT_SUB_LIO_SLGC, PARENT, $<ctxt>4,
2906                               GEDCOM_MAKE_NULL(val1));
2907                 }
2908               ;
2909
2910 lio_slgc_subs : /* empty */
2911               | lio_slgc_subs lio_slgc_sub
2912               ;
2913
2914 lio_slgc_sub  : lio_bapl_sub
2915               | lio_slgc_famc_sect  { OCCUR2(FAMC, 1, 1) }
2916               ;
2917
2918 lio_slgc_famc_sect : OPEN DELIM TAG_FAMC mand_pointer
2919                      { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
2920                                                                  XREF_FAM);
2921                        if (xr == NULL) HANDLE_ERROR;
2922                        $<ctxt>$
2923                          = start_element(ELT_SUB_LIO_SLGC_FAMC,
2924                                          PARENT, $1, $3, $4,
2925                                          GEDCOM_MAKE_XREF_PTR(val1, xr));
2926                        START(FAMC, $1, $<ctxt>$)
2927                      }
2928                      no_std_subs
2929                      { CHECK0 }
2930                      CLOSE
2931                      { end_element(ELT_SUB_LIO_SLGC_FAMC, PARENT, $<ctxt>5,
2932                                    GEDCOM_MAKE_NULL(val1));
2933                      }
2934                    ;
2935
2936 /* LDS SPOUSE SEALING */
2937 lds_spouse_seal_sub : lss_slgs_sect
2938                     ;
2939
2940 lss_slgs_sect : OPEN DELIM TAG_SLGS
2941                 { $<ctxt>$ = start_element(ELT_SUB_LSS_SLGS,
2942                                            PARENT, $1, $3, NULL,
2943                                            GEDCOM_MAKE_NULL(val1));
2944                   START(SLGS, $1, $<ctxt>$) }
2945                 lss_slgs_subs
2946                 { CHECK0 }
2947                 CLOSE
2948                 { end_element(ELT_SUB_LIO_SLGC, PARENT, $<ctxt>4,
2949                               GEDCOM_MAKE_NULL(val1));
2950                 }
2951               ;
2952
2953 lss_slgs_subs : /* empty */
2954               | lss_slgs_subs lss_slgs_sub
2955               ;
2956
2957 lss_slgs_sub  : lss_slgs_stat_sect  { OCCUR2(STAT, 0, 1) }
2958               | lss_slgs_date_sect  { OCCUR2(DATE, 0, 1) }
2959               | lss_slgs_temp_sect  { OCCUR2(TEMP, 0, 1) }
2960               | lss_slgs_plac_sect  { OCCUR2(PLAC, 0, 1) }
2961               | source_cit_sub
2962               | note_struc_sub
2963               | no_std_sub
2964               ;
2965
2966 lss_slgs_stat_sect : OPEN DELIM TAG_STAT mand_line_item
2967                      { $<ctxt>$ = start_element(ELT_SUB_LSS_SLGS_STAT,
2968                                                 PARENT, $1, $3, $4,
2969                                                 GEDCOM_MAKE_STRING(val1, $4));
2970                        START(STAT, $1, $<ctxt>$)
2971                      }
2972                      no_std_subs
2973                      { CHECK0 }
2974                      CLOSE
2975                      { end_element(ELT_SUB_LSS_SLGS_STAT, PARENT, $<ctxt>5,
2976                                    GEDCOM_MAKE_NULL(val1));
2977                      }
2978                    ;
2979 lss_slgs_date_sect : OPEN DELIM TAG_DATE mand_line_item
2980                      { struct date_value dv = gedcom_parse_date($4);
2981                        $<ctxt>$ = start_element(ELT_SUB_LSS_SLGS_DATE,
2982                                                 PARENT, $1, $3, $4,
2983                                                 GEDCOM_MAKE_DATE(val1, dv));
2984                        START(DATE, $1, $<ctxt>$)
2985                      }
2986                      no_std_subs
2987                      { CHECK0 }
2988                      CLOSE
2989                      { end_element(ELT_SUB_LSS_SLGS_DATE, PARENT, $<ctxt>5,
2990                                    GEDCOM_MAKE_NULL(val1));
2991                      }
2992                    ;
2993 lss_slgs_temp_sect : OPEN DELIM TAG_TEMP mand_line_item
2994                      { $<ctxt>$ = start_element(ELT_SUB_LSS_SLGS_TEMP,
2995                                                 PARENT, $1, $3, $4,
2996                                                 GEDCOM_MAKE_STRING(val1, $4));
2997                        START(TEMP, $1, $<ctxt>$)
2998                      }
2999                      no_std_subs
3000                      { CHECK0 }
3001                      CLOSE
3002                      { end_element(ELT_SUB_LSS_SLGS_TEMP, PARENT, $<ctxt>5,
3003                                    GEDCOM_MAKE_NULL(val1));
3004                      }
3005                    ;
3006 lss_slgs_plac_sect : OPEN DELIM TAG_PLAC mand_line_item
3007                      { $<ctxt>$ = start_element(ELT_SUB_LSS_SLGS_PLAC,
3008                                                 PARENT, $1, $3, $4,
3009                                                 GEDCOM_MAKE_STRING(val1, $4));
3010                        START(PLAC, $1, $<ctxt>$)
3011                      }
3012                      no_std_subs
3013                      { CHECK0 }
3014                      CLOSE
3015                      { end_element(ELT_SUB_LSS_SLGS_PLAC, PARENT, $<ctxt>5,
3016                                    GEDCOM_MAKE_NULL(val1));
3017                      }
3018                    ;
3019
3020 /* MULTIMEDIA LINK */
3021 multim_link_sub : multim_obje_link_sect
3022                 | multim_obje_emb_sect
3023                 ;
3024
3025 multim_obje_link_sect : OPEN DELIM TAG_OBJE DELIM POINTER
3026                         { struct xref_value *xr = gedcom_parse_xref($5,
3027                                                                     XREF_USED,
3028                                                                     XREF_OBJE);
3029                           if (xr == NULL) HANDLE_ERROR;
3030                           $<ctxt>$
3031                             = start_element(ELT_SUB_MULTIM_OBJE,
3032                                             PARENT, $1, $3, $5,
3033                                             GEDCOM_MAKE_XREF_PTR(val1, xr));
3034                           START(OBJE, $1, $<ctxt>$)
3035                         }
3036                         no_std_subs
3037                         { CHECK0 }
3038                         CLOSE
3039                         { end_element(ELT_SUB_MULTIM_OBJE, PARENT, $<ctxt>6,
3040                                       GEDCOM_MAKE_NULL(val1));
3041                         }
3042                       ;
3043
3044 multim_obje_emb_sect : OPEN DELIM TAG_OBJE
3045                        { $<ctxt>$ = start_element(ELT_SUB_MULTIM_OBJE,
3046                                                   PARENT, $1, $3, NULL,
3047                                                   GEDCOM_MAKE_NULL(val1));
3048                          START(OBJE, $1, $<ctxt>$)
3049                        }
3050                        multim_obje_emb_subs
3051                        { CHECK2(FORM,FILE) }
3052                        CLOSE
3053                        { end_element(ELT_SUB_MULTIM_OBJE, PARENT, $<ctxt>4,
3054                                      GEDCOM_MAKE_NULL(val1));
3055                        }
3056                      ;
3057
3058 multim_obje_emb_subs : /* empty */
3059                      | multim_obje_emb_subs multim_obje_emb_sub
3060                      ;
3061
3062 multim_obje_emb_sub : multim_obje_form_sect  { OCCUR2(FORM, 1, 1) }
3063                     | multim_obje_titl_sect  { OCCUR2(TITL, 0, 1) }
3064                     | multim_obje_file_sect  { OCCUR2(FILE, 1, 1) }
3065                     | note_struc_sub
3066                     | no_std_sub
3067                     ;
3068
3069 multim_obje_form_sect : OPEN DELIM TAG_FORM mand_line_item
3070                         { $<ctxt>$
3071                             = start_element(ELT_SUB_MULTIM_OBJE_FORM,
3072                                             PARENT, $1, $3, $4,
3073                                             GEDCOM_MAKE_STRING(val1, $4));
3074                           START(FORM, $1, $<ctxt>$)
3075                         }
3076                         no_std_subs
3077                         { CHECK0 }
3078                         CLOSE
3079                         { end_element(ELT_SUB_MULTIM_OBJE_FORM,
3080                                       PARENT, $<ctxt>5,
3081                                       GEDCOM_MAKE_NULL(val1));
3082                         }
3083                       ;
3084 multim_obje_titl_sect : OPEN DELIM TAG_TITL mand_line_item
3085                         { $<ctxt>$
3086                             = start_element(ELT_SUB_MULTIM_OBJE_TITL,
3087                                             PARENT, $1, $3, $4,
3088                                             GEDCOM_MAKE_STRING(val1, $4));
3089                           START(TITL, $1, $<ctxt>$)
3090                         }
3091                         no_std_subs
3092                         { CHECK0 }
3093                         CLOSE
3094                         { end_element(ELT_SUB_MULTIM_OBJE_TITL,
3095                                       PARENT, $<ctxt>5,
3096                                       GEDCOM_MAKE_NULL(val1));
3097                         }
3098                       ;
3099 multim_obje_file_sect : OPEN DELIM TAG_FILE mand_line_item
3100                         { $<ctxt>$
3101                             = start_element(ELT_SUB_MULTIM_OBJE_FILE,
3102                                             PARENT, $1, $3, $4,
3103                                             GEDCOM_MAKE_STRING(val1, $4));
3104                           START(FILE, $1, $<ctxt>$)
3105                         }
3106                         no_std_subs
3107                         { CHECK0 }
3108                         CLOSE
3109                         { end_element(ELT_SUB_MULTIM_OBJE_FILE,
3110                                       PARENT, $<ctxt>5,
3111                                       GEDCOM_MAKE_NULL(val1));
3112                         }
3113                       ;
3114
3115 /* NOTE STRUCTURE */
3116 note_struc_sub : note_struc_link_sect  /* 0:M */
3117                | note_struc_emb_sect  /* 0:M */
3118                ;
3119
3120 note_struc_link_sect : OPEN DELIM TAG_NOTE DELIM POINTER
3121                        { struct xref_value *xr = gedcom_parse_xref($5,
3122                                                                    XREF_USED,
3123                                                                    XREF_NOTE);
3124                          if (xr == NULL) HANDLE_ERROR;
3125                          $<ctxt>$
3126                            = start_element(ELT_SUB_NOTE,
3127                                            PARENT, $1, $3, $5,
3128                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
3129                          START(NOTE, $1, $<ctxt>$)
3130                        }
3131                        note_struc_link_subs
3132                        { CHECK0 }
3133                        CLOSE
3134                        { end_element(ELT_SUB_NOTE, PARENT, $<ctxt>6,
3135                                      GEDCOM_MAKE_NULL(val1));
3136                        }
3137                      ;
3138
3139 note_struc_link_subs : /* empty */
3140                      | note_struc_link_subs note_struc_link_sub
3141                      ;
3142
3143 note_struc_link_sub : source_cit_sub
3144                     | no_std_sub
3145                     ;
3146
3147 note_struc_emb_sect : OPEN DELIM TAG_NOTE opt_line_item
3148                       { $<ctxt>$
3149                           = start_element(ELT_SUB_NOTE,
3150                                           PARENT, $1, $3, $4,
3151                                          GEDCOM_MAKE_NULL_OR_STRING(val1, $4));
3152                         reset_buffer(&concat_buffer);
3153                         if ($4)
3154                           safe_buf_append(&concat_buffer, $4);
3155                         START(NOTE, $1, $<ctxt>$)
3156                       }
3157                       note_struc_emb_subs
3158                       { CHECK0 }
3159                       CLOSE
3160                       { char* complete = get_buf_string(&concat_buffer);
3161                         end_element(ELT_SUB_NOTE, PARENT, $<ctxt>5,
3162                                     GEDCOM_MAKE_STRING(val1, complete));
3163                       }
3164                     ;
3165
3166 note_struc_emb_subs : /* empty */
3167                     | note_struc_emb_subs note_struc_emb_sub
3168                     ;
3169
3170 note_struc_emb_sub  : continuation_sub
3171                     | source_cit_sub
3172                     | no_std_sub
3173                     ;
3174
3175 /* PERSONAL NAME STRUCTURE */
3176 pers_name_struc_sub : pers_name_sect /* 0:M */
3177                     ;
3178
3179 pers_name_sect : OPEN DELIM TAG_NAME mand_line_item
3180                  { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME,
3181                                             PARENT, $1, $3, $4,
3182                                             GEDCOM_MAKE_STRING(val1, $4));
3183                    START(NAME, $1, $<ctxt>$)
3184                  }
3185                  pers_name_subs
3186                  { CHECK0 }
3187                  CLOSE
3188                  { end_element(ELT_SUB_PERS_NAME, PARENT, $<ctxt>5,
3189                                GEDCOM_MAKE_NULL(val1));
3190                  }
3191                ;
3192
3193 pers_name_subs : /* empty */
3194                | pers_name_subs pers_name_sub
3195                ;
3196
3197 pers_name_sub  : pers_name_npfx_sect  { OCCUR2(NPFX, 0, 1) }
3198                | pers_name_givn_sect  { OCCUR2(GIVN, 0, 1) }
3199                | pers_name_nick_sect  { OCCUR2(NICK, 0, 1) }
3200                | pers_name_spfx_sect  { OCCUR2(SPFX, 0, 1) }
3201                | pers_name_surn_sect  { OCCUR2(SURN, 0, 1) }
3202                | pers_name_nsfx_sect  { OCCUR2(NSFX, 0, 1) }
3203                | source_cit_sub
3204                | note_struc_sub
3205                | no_std_sub
3206                ;
3207
3208 pers_name_npfx_sect : OPEN DELIM TAG_NPFX mand_line_item
3209                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_NPFX,
3210                                                  PARENT, $1, $3, $4,
3211                                                  GEDCOM_MAKE_STRING(val1, $4));
3212                         START(NPFX, $1, $<ctxt>$)
3213                       }
3214                       no_std_subs
3215                       { CHECK0 }
3216                       CLOSE
3217                       { end_element(ELT_SUB_PERS_NAME_NPFX, PARENT, $<ctxt>5,
3218                                     GEDCOM_MAKE_NULL(val1));
3219                       }
3220                     ;
3221 pers_name_givn_sect : OPEN DELIM TAG_GIVN mand_line_item
3222                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_GIVN,
3223                                                  PARENT, $1, $3, $4,
3224                                                  GEDCOM_MAKE_STRING(val1, $4));
3225                         START(GIVN, $1, $<ctxt>$)
3226                       }
3227                       no_std_subs
3228                       { CHECK0 }
3229                       CLOSE
3230                       { end_element(ELT_SUB_PERS_NAME_GIVN, PARENT, $<ctxt>5,
3231                                     GEDCOM_MAKE_NULL(val1));
3232                       }
3233                     ;
3234 pers_name_nick_sect : OPEN DELIM TAG_NICK mand_line_item
3235                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_NICK,
3236                                                  PARENT, $1, $3, $4,
3237                                                  GEDCOM_MAKE_STRING(val1, $4));
3238                         START(NICK, $1, $<ctxt>$)
3239                       }
3240                       no_std_subs
3241                       { CHECK0 }
3242                       CLOSE
3243                       { end_element(ELT_SUB_PERS_NAME_NICK, PARENT, $<ctxt>5,
3244                                     GEDCOM_MAKE_NULL(val1));
3245                       }
3246                     ;
3247 pers_name_spfx_sect : OPEN DELIM TAG_SPFX mand_line_item
3248                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_SPFX,
3249                                                  PARENT, $1, $3, $4,
3250                                                  GEDCOM_MAKE_STRING(val1, $4));
3251                         START(SPFX, $1, $<ctxt>$)
3252                       }
3253                       no_std_subs
3254                       { CHECK0 }
3255                       CLOSE
3256                       { end_element(ELT_SUB_PERS_NAME_SPFX, PARENT, $<ctxt>5,
3257                                     GEDCOM_MAKE_NULL(val1));
3258                       }
3259                     ;
3260 pers_name_surn_sect : OPEN DELIM TAG_SURN mand_line_item
3261                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_SURN,
3262                                                  PARENT, $1, $3, $4,
3263                                                  GEDCOM_MAKE_STRING(val1, $4));
3264                         START(SURN, $1, $<ctxt>$)
3265                       }
3266                       no_std_subs
3267                       { CHECK0 }
3268                       CLOSE
3269                       { end_element(ELT_SUB_PERS_NAME_SURN, PARENT, $<ctxt>5,
3270                                     GEDCOM_MAKE_NULL(val1));
3271                       }
3272                     ;
3273 pers_name_nsfx_sect : OPEN DELIM TAG_NSFX mand_line_item
3274                       { $<ctxt>$ = start_element(ELT_SUB_PERS_NAME_NSFX,
3275                                                  PARENT, $1, $3, $4,
3276                                                  GEDCOM_MAKE_STRING(val1, $4));
3277                         START(NSFX, $1, $<ctxt>$)
3278                       }
3279                       no_std_subs
3280                       { CHECK0 }
3281                       CLOSE
3282                       { end_element(ELT_SUB_PERS_NAME_NSFX, PARENT, $<ctxt>5,
3283                                     GEDCOM_MAKE_NULL(val1));
3284                       }
3285                     ;
3286
3287 /* PLACE STRUCTURE */
3288 place_struc_sub : place_struc_plac_sect /* 0:M */
3289                 ;
3290
3291 place_struc_plac_sect : OPEN DELIM TAG_PLAC mand_line_item
3292                         { $<ctxt>$
3293                             = start_element(ELT_SUB_PLAC,
3294                                             PARENT, $1, $3, $4,
3295                                             GEDCOM_MAKE_STRING(val1, $4));
3296                           START(PLAC, $1, $<ctxt>$)
3297                         }
3298                         place_struc_plac_subs
3299                         { CHECK0 }
3300                         CLOSE
3301                         { end_element(ELT_SUB_PLAC, PARENT, $<ctxt>5,
3302                                       GEDCOM_MAKE_NULL(val1));
3303                         }
3304                       ;
3305
3306 place_struc_plac_subs : /* empty */
3307                       | place_struc_plac_subs place_struc_plac_sub
3308                       ;
3309
3310 place_struc_plac_sub : place_plac_form_sect  { OCCUR2(FORM, 0, 1) }
3311                      | source_cit_sub
3312                      | note_struc_sub
3313                      | no_std_sub
3314                      ;
3315
3316 place_plac_form_sect : OPEN DELIM TAG_FORM mand_line_item
3317                        { $<ctxt>$
3318                            = start_element(ELT_SUB_PLAC_FORM,
3319                                            PARENT, $1, $3, $4,
3320                                            GEDCOM_MAKE_STRING(val1, $4));
3321                          START(FORM, $1, $<ctxt>$)
3322                        }
3323                        no_std_subs
3324                        { CHECK0 }
3325                        CLOSE
3326                        { end_element(ELT_SUB_PLAC_FORM, PARENT, $<ctxt>5,
3327                                      GEDCOM_MAKE_NULL(val1));
3328                        }
3329                      ;
3330
3331 /* SOURCE_CITATION */
3332 source_cit_sub : source_cit_link_sect /* 0:M */
3333                | source_cit_emb_sect /* 0:M */
3334                ;
3335
3336 source_cit_link_sect : OPEN DELIM TAG_SOUR DELIM POINTER
3337                        { struct xref_value *xr = gedcom_parse_xref($5,
3338                                                                    XREF_USED,
3339                                                                    XREF_SOUR);
3340                          if (xr == NULL) HANDLE_ERROR;
3341                          $<ctxt>$
3342                            = start_element(ELT_SUB_SOUR,
3343                                            PARENT, $1, $3, $5,
3344                                            GEDCOM_MAKE_XREF_PTR(val1, xr));
3345                          START(SOUR, $1, $<ctxt>$)
3346                        }
3347                        source_cit_link_subs
3348                        { CHECK0 }
3349                        CLOSE
3350                        { end_element(ELT_SUB_SOUR, PARENT, $<ctxt>6,
3351                                      GEDCOM_MAKE_NULL(val1));
3352                        }
3353                      ;
3354
3355 source_cit_link_subs : /* empty */
3356                      | source_cit_link_subs source_cit_link_sub
3357                      ;
3358
3359 source_cit_link_sub : source_cit_page_sect  { OCCUR2(PAGE, 0, 1) }
3360                     | source_cit_even_sect  { OCCUR2(EVEN, 0, 1) }
3361                     | source_cit_data_sect  { OCCUR2(DATA, 0, 1) }
3362                     | source_cit_quay_sect  { OCCUR2(QUAY, 0, 1) }
3363                     | multim_link_sub
3364                     | note_struc_sub
3365                     | no_std_sub
3366                     ;
3367
3368 source_cit_page_sect : OPEN DELIM TAG_PAGE mand_line_item
3369                        { $<ctxt>$
3370                            = start_element(ELT_SUB_SOUR_PAGE,
3371                                            PARENT, $1, $3, $4,
3372                                            GEDCOM_MAKE_STRING(val1, $4));
3373                          START(PAGE, $1, $<ctxt>$)
3374                        }
3375                        no_std_subs
3376                        { CHECK0 }
3377                        CLOSE
3378                        { end_element(ELT_SUB_SOUR_PAGE, PARENT, $<ctxt>5,
3379                                      GEDCOM_MAKE_NULL(val1));
3380                        }
3381                      ;
3382
3383 source_cit_even_sect : OPEN DELIM TAG_EVEN mand_line_item
3384                        { $<ctxt>$
3385                            = start_element(ELT_SUB_SOUR_EVEN,
3386                                            PARENT, $1, $3, $4,
3387                                            GEDCOM_MAKE_STRING(val1, $4));
3388                          START(EVEN, $1, $<ctxt>$)
3389                        }
3390                        source_cit_even_subs
3391                        { CHECK0 }
3392                        CLOSE
3393                        { end_element(ELT_SUB_SOUR_EVEN, PARENT, $<ctxt>5,
3394                                      GEDCOM_MAKE_NULL(val1));
3395                        }
3396                      ;
3397
3398 source_cit_even_subs : /* empty */
3399                      | source_cit_even_subs source_cit_even_sub
3400                      ;
3401
3402 source_cit_even_sub  : source_cit_even_role_sect  { OCCUR2(ROLE, 0, 1) }
3403                      | no_std_sub
3404                      ;
3405
3406 source_cit_even_role_sect : OPEN DELIM TAG_ROLE mand_line_item
3407                           { $<ctxt>$
3408                               = start_element(ELT_SUB_SOUR_EVEN_ROLE,
3409                                               PARENT, $1, $3, $4,
3410                                               GEDCOM_MAKE_STRING(val1, $4));
3411                             START(ROLE, $1, $<ctxt>$)
3412                           }
3413                           no_std_subs
3414                           { CHECK0 }
3415                           CLOSE
3416                           { end_element(ELT_SUB_SOUR_EVEN_ROLE,
3417                                         PARENT, $<ctxt>5,
3418                                         GEDCOM_MAKE_NULL(val1));
3419                           }
3420                           ;
3421
3422 source_cit_data_sect : OPEN DELIM TAG_DATA
3423                        { $<ctxt>$ = start_element(ELT_SUB_SOUR_DATA,
3424                                                   PARENT, $1, $3, NULL,
3425                                                   GEDCOM_MAKE_NULL(val1));
3426                          START(DATA, $1, $<ctxt>$)
3427                        }
3428                        source_cit_data_subs
3429                        { CHECK0 }
3430                        CLOSE
3431                        { end_element(ELT_SUB_SOUR_DATA, PARENT, $<ctxt>4,
3432                                      GEDCOM_MAKE_NULL(val1));
3433                        }
3434                      ;
3435
3436 source_cit_data_subs : /* empty */
3437                      | source_cit_data_subs source_cit_data_sub
3438                      ;
3439
3440 source_cit_data_sub : source_cit_data_date_sect  { OCCUR2(DATE, 0, 1) }
3441                     | source_cit_text_sect  /* 0:M */
3442                     | no_std_sub
3443                     ;
3444
3445 source_cit_data_date_sect : OPEN DELIM TAG_DATE mand_line_item
3446                             { struct date_value dv = gedcom_parse_date($4);
3447                               $<ctxt>$
3448                                 = start_element(ELT_SUB_SOUR_DATA_DATE,
3449                                                 PARENT, $1, $3, $4,
3450                                                 GEDCOM_MAKE_DATE(val1, dv));
3451                               START(DATE, $1, $<ctxt>$)
3452                             }
3453                             no_std_subs
3454                             { CHECK0 }
3455                             CLOSE
3456                             { end_element(ELT_SUB_SOUR_DATA_DATE,
3457                                           PARENT, $<ctxt>5,
3458                                           GEDCOM_MAKE_NULL(val1));
3459                             }
3460                           ;
3461
3462 source_cit_text_sect : OPEN DELIM TAG_TEXT mand_line_item
3463                        { $<ctxt>$
3464                            = start_element(ELT_SUB_SOUR_TEXT,
3465                                            PARENT, $1, $3, $4,
3466                                            GEDCOM_MAKE_STRING(val1, $4));
3467                         reset_buffer(&concat_buffer);
3468                         safe_buf_append(&concat_buffer, $4);
3469                         START(TEXT, $1, $<ctxt>$)
3470                        }
3471                        source_cit_text_subs
3472                        { CHECK0 }
3473                        CLOSE
3474                        { char* complete = get_buf_string(&concat_buffer);
3475                          end_element(ELT_SUB_SOUR_TEXT, PARENT, $<ctxt>5,
3476                                      GEDCOM_MAKE_STRING(val1, complete));
3477                        }
3478                      ;
3479
3480 source_cit_text_subs : /* empty */
3481                      | source_cit_text_subs source_cit_text_sub
3482                      ;
3483
3484 source_cit_text_sub : continuation_sub
3485                     | no_std_sub
3486                     ;
3487
3488 source_cit_quay_sect : OPEN DELIM TAG_QUAY mand_line_item
3489                        { $<ctxt>$
3490                            = start_element(ELT_SUB_SOUR_QUAY,
3491                                            PARENT, $1, $3, $4,
3492                                            GEDCOM_MAKE_STRING(val1, $4));
3493                          START(QUAY, $1, $<ctxt>$)
3494                        }
3495                        no_std_subs
3496                        { CHECK0 }
3497                        CLOSE
3498                        { end_element(ELT_SUB_SOUR_QUAY, PARENT, $<ctxt>5,
3499                                      GEDCOM_MAKE_NULL(val1));
3500                        }
3501                      ;
3502
3503 source_cit_emb_sect : OPEN DELIM TAG_SOUR mand_line_item
3504                       { $<ctxt>$ = start_element(ELT_SUB_SOUR,
3505                                                  PARENT, $1, $3, $4,
3506                                                  GEDCOM_MAKE_STRING(val1, $4));
3507                         reset_buffer(&concat_buffer);
3508                         safe_buf_append(&concat_buffer, $4);
3509                         START(SOUR, $1, $<ctxt>$)
3510                       }
3511                       source_cit_emb_subs
3512                       { CHECK0 }
3513                       CLOSE
3514                       { char* complete = get_buf_string(&concat_buffer);
3515                         end_element(ELT_SUB_SOUR, PARENT, $<ctxt>5,
3516                                     GEDCOM_MAKE_STRING(val1, complete));
3517                       }
3518                     ;
3519
3520 source_cit_emb_subs : /* empty */
3521                     | source_cit_emb_subs source_cit_emb_sub
3522                     ;
3523
3524 source_cit_emb_sub : continuation_sub
3525                    | source_cit_text_sect  /* 0:M */
3526                    | note_struc_sub
3527                    | no_std_sub
3528                    ;
3529
3530 /* SOURCE REPOSITORY CITATION */
3531 source_repos_cit_sub : source_repos_repo_sect  { OCCUR2(REPO, 0, 1) }
3532                      ;
3533
3534 source_repos_repo_sect : OPEN DELIM TAG_REPO mand_pointer
3535                          { struct xref_value *xr
3536                              = gedcom_parse_xref($4, XREF_USED, XREF_REPO);
3537                            if (xr == NULL) HANDLE_ERROR;
3538                            $<ctxt>$
3539                              = start_element(ELT_SUB_REPO,
3540                                              PARENT, $1, $3, $4,
3541                                              GEDCOM_MAKE_XREF_PTR(val1, xr));
3542                            START(REPO, $1, $<ctxt>$)
3543                          }
3544                          source_repos_repo_subs
3545                          { CHECK0 }
3546                          CLOSE
3547                          { end_element(ELT_SUB_REPO, PARENT, $<ctxt>5,
3548                                        GEDCOM_MAKE_NULL(val1));
3549                          }
3550                        ;
3551
3552 source_repos_repo_subs : /* empty */
3553                        | source_repos_repo_subs source_repos_repo_sub
3554                        ;
3555
3556 source_repos_repo_sub  : note_struc_sub
3557                        | caln_sect  /* 0:M */
3558                        | no_std_sub
3559                        ;
3560
3561 caln_sect : OPEN DELIM TAG_CALN mand_line_item
3562             { $<ctxt>$ = start_element(ELT_SUB_REPO_CALN,
3563                                        PARENT, $1, $3, $4,
3564                                        GEDCOM_MAKE_STRING(val1, $4));
3565               START(CALN, $1, $<ctxt>$)
3566             }
3567             caln_subs
3568             { CHECK0 }
3569             CLOSE
3570             { end_element(ELT_SUB_REPO_CALN, PARENT, $<ctxt>5,
3571                           GEDCOM_MAKE_NULL(val1));
3572             }
3573           ;
3574
3575 caln_subs : /* empty */
3576           | caln_subs caln_sub
3577           ;
3578
3579 caln_sub  : caln_medi_sect  { OCCUR2(MEDI, 0, 1) }
3580           | no_std_sub
3581           ;
3582
3583 caln_medi_sect : OPEN DELIM TAG_MEDI mand_line_item
3584                  { $<ctxt>$ = start_element(ELT_SUB_REPO_CALN_MEDI,
3585                                             PARENT, $1, $3, $4,
3586                                             GEDCOM_MAKE_STRING(val1, $4));
3587                    START(MEDI, $1, $<ctxt>$)
3588                  }
3589                  no_std_subs
3590                  { CHECK0 }
3591                  CLOSE
3592                  { end_element(ELT_SUB_REPO_CALN_MEDI, PARENT, $<ctxt>5,
3593                                GEDCOM_MAKE_NULL(val1));
3594                  }
3595                ;
3596
3597 /* SPOUSE TO FAMILY LINK */
3598 spou_fam_link_sub : spou_fam_fams_sect  /* 0:M */
3599                   ;
3600
3601 spou_fam_fams_sect : OPEN DELIM TAG_FAMS mand_pointer
3602                      { struct xref_value *xr = gedcom_parse_xref($4, XREF_USED,
3603                                                                  XREF_FAM);
3604                        if (xr == NULL) HANDLE_ERROR;
3605                        $<ctxt>$
3606                          = start_element(ELT_SUB_FAMS,
3607                                          PARENT, $1, $3, $4,
3608                                          GEDCOM_MAKE_XREF_PTR(val1, xr));
3609                        START(FAMS, $1, $<ctxt>$)
3610                      }
3611                      spou_fam_fams_subs
3612                      { CHECK0 }
3613                      CLOSE
3614                      { end_element(ELT_SUB_FAMS, PARENT, $<ctxt>5,
3615                                    GEDCOM_MAKE_NULL(val1));
3616                      }
3617                    ;
3618
3619 spou_fam_fams_subs : /* empty */
3620                    | spou_fam_fams_subs spou_fam_fams_sub
3621                    ;
3622
3623 spou_fam_fams_sub  : note_struc_sub
3624                    | no_std_sub
3625                    ;
3626
3627 /*********************************************************************/
3628 /**** General                                                     ****/
3629 /*********************************************************************/
3630
3631 no_std_subs : /* empty */
3632             | no_std_subs no_std_sub
3633             ;
3634
3635 no_std_sub  : user_sect /* 0:M */
3636             | gen_sect
3637             | error error_subs
3638               CLOSE  { HANDLE_ERROR }
3639             ;
3640
3641 no_std_rec  : user_rec /* 0:M */
3642             | gen_rec
3643             | error error_subs
3644               CLOSE  { HANDLE_ERROR }
3645             ;
3646
3647 user_rec    : OPEN DELIM opt_xref USERTAG
3648               { if ($4.string[0] != '_') {
3649                   if (compat_mode(C_551_TAGS)
3650                       && compat_check_551_tag($4.string, &usertag_buffer)) {
3651                     $4.string = get_buf_string(&usertag_buffer);
3652                   }
3653                   else {
3654                     gedcom_error(_("Undefined tag (and not a valid user tag): %s"),
3655                                  $4);
3656                     YYERROR;
3657                   }
3658                 }
3659               }
3660               opt_value
3661               { struct xref_value *xr = NULL;
3662                 if ($3 != NULL) {
3663                   xr = gedcom_parse_xref($3, XREF_DEFINED, XREF_USER);
3664                   if (xr == NULL) HANDLE_ERROR;
3665                 }
3666                 $<ctxt>$ = start_record(REC_USER,
3667                                         $1,
3668                                         GEDCOM_MAKE_NULL_OR_XREF_PTR(val1, xr),
3669                                         $4, $6, &val2);
3670                 START($4, $1, $<ctxt>$)
3671               }
3672               user_sects
3673               { CHECK0 }
3674               CLOSE
3675               { end_record(REC_USER, $<ctxt>7, GEDCOM_MAKE_NULL(val1)); }
3676             ;
3677 user_sect   : OPEN DELIM opt_xref USERTAG
3678               { if ($4.string[0] != '_') {
3679                   if (compat_mode(C_551_TAGS)
3680                       && compat_check_551_tag($4.string, &usertag_buffer)) {
3681                     $4.string = get_buf_string(&usertag_buffer);
3682                   }
3683                   else if (compat_mode(C_SUBM_COMM) &&
3684                            compat_check_subm_comm($4.string, get_parenttag(0),
3685                                                   &usertag_buffer)) {
3686                     $4.string = get_buf_string(&usertag_buffer);
3687                   }
3688                   else {
3689                     gedcom_error(_("Undefined tag (and not a valid user tag): %s"),
3690                                  $4);
3691                     YYERROR;
3692                   }
3693                 }
3694               }
3695               opt_value
3696               { $<ctxt>$ = start_element(ELT_USER, PARENT, $1, $4, $6, &val2);
3697                 START($4, $1, $<ctxt>$);
3698               }
3699               user_sects
3700               { CHECK0 }
3701               CLOSE
3702               { end_element(ELT_USER, PARENT, $<ctxt>7,
3703                             GEDCOM_MAKE_NULL(val1));
3704                 if (compat_mode(C_SUBM_COMM))
3705                   compat_close_subm_comm();
3706               }
3707             ;
3708
3709 user_sects   : /* empty */     { }
3710             | user_sects user_sect { }
3711             | user_sects gen_sect
3712               { if (compat_mode(C_SUBM_COMM)) {
3713                 }
3714                 else {
3715                   gedcom_error(_("Standard tag not allowed in user section"));
3716                   YYERROR;
3717                 }
3718               }
3719             ;
3720
3721 opt_xref    : /* empty */        { $$ = NULL; }
3722             | POINTER DELIM        { $$ = $1; }
3723             ;
3724
3725 opt_value   : /* empty */        { GEDCOM_MAKE_NULL(val2);
3726                                    $$ = NULL; }
3727             | DELIM POINTER      { struct xref_value *xr
3728                                      = gedcom_parse_xref($2, XREF_USED,
3729                                                          XREF_USER);
3730                                    GEDCOM_MAKE_XREF_PTR(val2, xr);
3731                                    $$ = $2; }
3732             | DELIM line_item    { GEDCOM_MAKE_STRING(val2, $2);
3733                                    $$ = $2; }
3734             ;
3735
3736 mand_pointer : /* empty */ { gedcom_error(_("Missing pointer")); YYERROR; }
3737              | DELIM POINTER { gedcom_debug_print("==Ptr: %s==", $2);
3738                                $$ = $2; }
3739              ;
3740
3741 mand_line_item : /* empty */
3742                  { if (compat_mode(C_NO_REQUIRED_VALUES)) {
3743                      gedcom_debug_print("==Val: ==");
3744                      $$ = "";
3745                    }
3746                    else {
3747                      gedcom_error(_("Missing value")); YYERROR;
3748                    }
3749                  }
3750                | DELIM line_item { gedcom_debug_print("==Val: %s==", $2);
3751                                    $$ = $2; }
3752                ;
3753
3754 opt_line_item : /* empty */     { $$ = NULL; }
3755               | DELIM line_item { gedcom_debug_print("==Val: %s==", $2);
3756                                   $$ = $2; }
3757               ;
3758
3759 line_item   : anychar  { size_t i;
3760                          reset_buffer(&line_item_buffer);
3761                          /* The following also takes care of '@@' */
3762                          if (!strncmp($1, "@@", 3))
3763                            SAFE_BUF_ADDCHAR(&line_item_buffer, '@')
3764                          else
3765                            for (i=0; i < strlen($1); i++)
3766                              SAFE_BUF_ADDCHAR(&line_item_buffer, $1[i])
3767                          $$ = get_buf_string(&line_item_buffer);
3768                        }
3769             | ESCAPE   { size_t i;
3770                          reset_buffer(&line_item_buffer);
3771                          for (i=0; i < strlen($1); i++)
3772                            SAFE_BUF_ADDCHAR(&line_item_buffer, $1[i])
3773                          $$ = get_buf_string(&line_item_buffer);
3774                        }
3775             | line_item anychar
3776                   { size_t i;
3777                     /* The following also takes care of '@@' */
3778                     if (!strncmp($2, "@@", 3))
3779                       SAFE_BUF_ADDCHAR(&line_item_buffer, '@')
3780                     else
3781                       for (i=0; i < strlen($2); i++)
3782                         SAFE_BUF_ADDCHAR(&line_item_buffer, $2[i])
3783                     $$ = get_buf_string(&line_item_buffer);
3784                   }
3785             | line_item ESCAPE
3786                   { size_t i;
3787                     for (i=0; i < strlen($2); i++)
3788                       SAFE_BUF_ADDCHAR(&line_item_buffer, $2[i])
3789                     $$ = get_buf_string(&line_item_buffer);
3790                   }
3791             | line_item error anychar { HANDLE_ERROR; }
3792             | line_item error ESCAPE  { HANDLE_ERROR; }
3793             ;
3794
3795 anychar     : ANYCHAR        { }
3796             | DELIM        { }
3797             ;
3798
3799 error_subs  : /* empty */
3800             | error_subs error_sect
3801             ;
3802
3803 error_sect  : OPEN DELIM opt_xref anytag opt_value error_subs CLOSE { }
3804             ;
3805
3806 gen_sect    : OPEN DELIM opt_xref anystdtag
3807               { if (compat_mode(C_SUBM_COMM)
3808                     && compat_check_subm_comm_cont($4.string)) {
3809                   /* Will pass here */
3810                 }
3811                 else {
3812                   INVALID_TAG($4.string);
3813                 }
3814               }
3815               opt_value
3816               { if (compat_mode(C_SUBM_COMM)) {
3817                   $<ctxt>$ = compat_subm_comm_cont_start(PARENT, $6);
3818                 }
3819               }
3820               opt_sects CLOSE
3821               { if (compat_mode(C_SUBM_COMM))
3822                   compat_subm_comm_cont_end(PARENT, $<ctxt>7);
3823               }
3824             ;
3825
3826 gen_rec : gen_rec_top
3827         | gen_rec_norm
3828         ;
3829
3830 gen_rec_norm : OPEN DELIM opt_xref anystdtag
3831                { INVALID_TOP_TAG($4.string) }
3832                opt_value opt_sects CLOSE
3833                { }
3834              ;
3835
3836 gen_rec_top : OPEN DELIM anytoptag
3837               { gedcom_error(_("Missing cross-reference")); YYERROR; }
3838               opt_value opt_sects CLOSE
3839                 { }
3840             ;
3841
3842 opt_sects   : /* empty */     { }
3843             | opt_sects gen_sect { }
3844             ;
3845
3846 anytag      : USERTAG { }
3847             | anystdtag { }
3848             ;
3849
3850 anytoptag   : TAG_FAM
3851             | TAG_INDI
3852             | TAG_OBJE
3853             | TAG_NOTE
3854             | TAG_REPO
3855             | TAG_SOUR
3856             | TAG_SUBN
3857             | TAG_SUBM
3858             ;
3859
3860 anystdtag   : TAG_ABBR
3861             | TAG_ADDR
3862             | TAG_ADR1
3863             | TAG_ADR2   { }
3864             | TAG_ADOP   { }
3865             | TAG_AFN   { }
3866             | TAG_AGE   { }
3867             | TAG_AGNC   { }
3868             | TAG_ALIA   { }
3869             | TAG_ANCE   { }
3870             | TAG_ANCI   { }
3871             | TAG_ANUL   { }
3872             | TAG_ASSO   { }
3873             | TAG_AUTH   { }
3874             | TAG_BAPL   { }
3875             | TAG_BAPM   { }
3876             | TAG_BARM   { }
3877             | TAG_BASM   { }
3878             | TAG_BIRT   { }
3879             | TAG_BLES   { }
3880             | TAG_BLOB   { }
3881             | TAG_BURI   { }
3882             | TAG_CALN   { }
3883             | TAG_CAST   { }
3884             | TAG_CAUS   { }
3885             | TAG_CENS   { }
3886             | TAG_CHAN   { }
3887             | TAG_CHAR   { }
3888             | TAG_CHIL   { }
3889             | TAG_CHR   { }
3890             | TAG_CHRA   { }
3891             | TAG_CITY   { }
3892             | TAG_CONC   { }
3893             | TAG_CONF   { }
3894             | TAG_CONL   { }
3895             | TAG_CONT   { }
3896             | TAG_COPR   { }
3897             | TAG_CORP   { }
3898             | TAG_CREM   { }
3899             | TAG_CTRY   { }
3900             | TAG_DATA   { }
3901             | TAG_DATE   { }
3902             | TAG_DEAT   { }
3903             | TAG_DESC   { }
3904             | TAG_DESI   { }
3905             | TAG_DEST   { }
3906             | TAG_DIV   { }
3907             | TAG_DIVF   { }
3908             | TAG_DSCR   { }
3909             | TAG_EDUC   { }
3910             | TAG_EMIG   { }
3911             | TAG_ENDL   { }
3912             | TAG_ENGA   { }
3913             | TAG_EVEN   { }
3914             | TAG_FAM    { }
3915             | TAG_FAMC   { }
3916             | TAG_FAMS   { }
3917             | TAG_FCOM   { }
3918             | TAG_FILE   { }
3919             | TAG_FORM   { }
3920             | TAG_GEDC   { }
3921             | TAG_GIVN   { }
3922             | TAG_GRAD   { }
3923             | TAG_HEAD   { }
3924             | TAG_HUSB   { }
3925             | TAG_IDNO   { }
3926             | TAG_IMMI   { }
3927             | TAG_INDI   { }
3928             | TAG_LANG   { }
3929             | TAG_LEGA   { }
3930             | TAG_MARB   { }
3931             | TAG_MARC   { }
3932             | TAG_MARL   { }
3933             | TAG_MARR   { }
3934             | TAG_MARS   { }
3935             | TAG_MEDI   { }
3936             | TAG_NAME   { }
3937             | TAG_NATI   { }
3938             | TAG_NCHI   { }
3939             | TAG_NICK   { }
3940             | TAG_NMR   { }
3941             | TAG_NOTE   { }
3942             | TAG_NPFX   { }
3943             | TAG_NSFX   { }
3944             | TAG_OBJE   { }
3945             | TAG_OCCU   { }
3946             | TAG_ORDI   { }
3947             | TAG_ORDN   { }
3948             | TAG_PAGE   { }
3949             | TAG_PEDI   { }
3950             | TAG_PHON   { }
3951             | TAG_PLAC   { }
3952             | TAG_POST   { }
3953             | TAG_PROB   { }
3954             | TAG_PROP   { }
3955             | TAG_PUBL   { }
3956             | TAG_QUAY   { }
3957             | TAG_REFN   { }
3958             | TAG_RELA   { }
3959             | TAG_RELI   { }
3960             | TAG_REPO   { }
3961             | TAG_RESI   { }
3962             | TAG_RESN   { }
3963             | TAG_RETI   { }
3964             | TAG_RFN   { }
3965             | TAG_RIN   { }
3966             | TAG_ROLE   { }
3967             | TAG_SEX   { }
3968             | TAG_SLGC   { }
3969             | TAG_SLGS   { }
3970             | TAG_SOUR   { }
3971             | TAG_SPFX   { }
3972             | TAG_SSN   { }
3973             | TAG_STAE   { }
3974             | TAG_STAT   { }
3975             | TAG_SUBM   { }
3976             | TAG_SUBN   { }
3977             | TAG_SURN   { }
3978             | TAG_TEMP   { }
3979             | TAG_TEXT   { }
3980             | TAG_TIME   { }
3981             | TAG_TITL   { }
3982             | TAG_TRLR   { }
3983             | TAG_TYPE   { }
3984             | TAG_VERS   { }
3985             | TAG_WIFE   { }
3986             | TAG_WILL   { }
3987             ;
3988
3989 %%
3990
3991 /* Functions that handle the counting of subtags */
3992
3993 int* count_arrays[MAXGEDCLEVEL+1];
3994 char tag_stack[MAXGEDCLEVEL+1][MAXSTDTAGLEN+1];
3995 Gedcom_ctxt ctxt_stack[MAXGEDCLEVEL+1];
3996
3997 void push_countarray(int level)
3998 {
3999   int *count = NULL;
4000   gedcom_debug_print("Push Count level: %d, level: %d", count_level, level);
4001   if (count_level != level + 1) {
4002     gedcom_error(_("Internal error: count level mismatch"));
4003     exit(1);
4004   }
4005   if (count_level > MAXGEDCLEVEL) {
4006     gedcom_error(_("Internal error: count array overflow"));
4007     exit(1);
4008   }
4009   else {
4010     gedcom_debug_print("calloc countarray %d", count_level);
4011     count = (int *)calloc(YYNTOKENS, sizeof(int));
4012     if (count == NULL) {
4013       gedcom_error(_("Internal error: count array calloc error"));
4014       exit(1);
4015     }
4016     else {
4017       count_arrays[count_level] = count;
4018     }
4019   }
4020 }
4021
4022 void set_parenttag(const char* tag)
4023 {
4024   strncpy(tag_stack[count_level+1], tag, MAXSTDTAGLEN+1);
4025 }
4026
4027 void set_parentctxt(Gedcom_ctxt ctxt)
4028 {
4029   ctxt_stack[count_level+1] = ctxt;
4030 }
4031
4032 char* get_parenttag(int offset)
4033 {
4034   return tag_stack[count_level - offset];
4035 }
4036
4037 Gedcom_ctxt get_parentctxt(int offset)
4038 {
4039   return ctxt_stack[count_level - offset];
4040 }
4041
4042 int count_tag(int tag)
4043 {
4044   int *count = count_arrays[count_level];
4045   return ++count[tag - GEDCOMTAGOFFSET];
4046 }
4047
4048 int check_occurrence(int tag)
4049 {
4050   int *count = count_arrays[count_level];
4051   return (count[tag - GEDCOMTAGOFFSET] > 0);
4052 }
4053
4054 void pop_countarray()
4055 {
4056   int *count;
4057   gedcom_debug_print("Pop Count level: %d", count_level);
4058   if (count_level < 0) {
4059     gedcom_error(_("Internal error: count array underflow"));
4060     exit(1);
4061   }
4062   else {
4063     count = count_arrays[count_level];
4064     gedcom_debug_print("free countarray %d", count_level);
4065     free(count);
4066     count_arrays[count_level] = NULL;
4067   }
4068 }
4069
4070 void clean_up()
4071 {
4072   gedcom_debug_print("Cleanup countarrays");
4073   while (count_level > 0) {
4074     pop_countarray();
4075     --count_level;
4076   }
4077 }
4078
4079 void cleanup_concat_buffer()
4080 {
4081   cleanup_buffer(&concat_buffer);
4082 }
4083
4084 void cleanup_line_item_buffer()
4085 {
4086   cleanup_buffer(&line_item_buffer);
4087 }
4088
4089 void cleanup_usertag_buffer()
4090 {
4091   cleanup_buffer(&usertag_buffer);
4092 }
4093
4094 /* Enabling debug mode */
4095 /* level 0: no debugging */
4096 /* level 1: only internal */
4097 /* level 2: also bison */
4098 FILE* trace_output;
4099
4100 void gedcom_set_debug_level(int level, FILE* f)
4101 {
4102   if (f != NULL)
4103     trace_output = f;
4104   else
4105     trace_output = stderr;
4106   if (level > 0) {
4107     gedcom_high_level_debug = 1;
4108   }
4109   if (level > 1) {
4110 #if YYDEBUG != 0
4111     gedcom_debug = 1;
4112 #endif
4113   }
4114 }
4115
4116 int gedcom_debug_print(const char* s, ...)
4117 {
4118   int res = 0;
4119   if (gedcom_high_level_debug) {
4120     va_list ap;
4121     va_start(ap, s);
4122     res = vfprintf(trace_output, s, ap);
4123     va_end(ap);
4124     fprintf(trace_output, "\n");
4125   }
4126   return(res);
4127 }
4128
4129 /* Setting the error mechanism */
4130 void gedcom_set_error_handling(Gedcom_err_mech mechanism)
4131 {
4132   error_mechanism = mechanism;
4133 }