biber 2.3-1 / usr / share / perl5 / Biber / bcf.rnc

namespace bcf = "https://sourceforge.net/projects/biblatex"

start =
  element bcf:controlfile {
    # This is usually the same as the biblatex version string but not necessarily.
    # Sometimes the BCF format version doesn't change between biblatex releases
    attribute version { xsd:string {minLength="1"}},

    # "Global" Biber options. It's not clear what a non-global biber option
    # would be but just in case, we have the option ...
    element bcf:options {
      attribute component { "biber" },
      attribute type { "global" },
      output_encoding,
      input_encoding,
      debug,
      mincrossrefs,
      sortcase,
      sortfirstinits,
      sortupper
    },

    # Global BibLaTeX options. That is, options that apply to all
    # entrytypes (unless a more specifically scoped option is specified)
    element bcf:options {
      attribute component { "biblatex" },
      attribute type { "global" },
      alphaothers,
      labelalpha,
      labelnamespec,
      labeltitle,
      labeltitlespec,
      labeltitleyear,
      labeldate,
      labeldatespec,
      maxalphanames,
      maxbibnames,
      maxcitenames,
      maxitems,
      minalphanames,
      minbibnames,
      mincitenames,
      minitems,
      singletitle,
      sortalphaothers?,
      sortlocale,
      sortscheme,
      uniquelist,
      uniquename,
      useprefix,
      usenames
    },
    
    # Per-entrytype BibLaTeX options
    element bcf:options {
      attribute component { "biblatex" },
      attribute type { text },
      alphaothers?,
      labelalpha?,
      labelnamespec?,
      labeltitle?,
      labeltitlespec?,
      labeltitleyear?,
      labeldate?,
      labeldatespec?,
      maxalphanames?,
      maxbibnames?,
      maxcitenames?,
      maxitems?,
      minalphanames?,
      minbibnames?,
      mincitenames?,
      minitems?,
      singletitle?,
      skipbib?,
      skiplab?,
      skipbiblist?,
      skiplos?,
      sortalphaothers?,
      uniquelist?,
      uniquename?,
      useprefix?,
      usenames?
    }*,

    # Option scope
    element bcf:optionscope {
      attribute type { "GLOBAL" | "PER_TYPE" | "PER_ENTRY" },
      element bcf:option { xsd:string }+
    }+,
    
    # user field/entrytype mapping
    element bcf:sourcemap {
      element bcf:maps {
        attribute datatype { "bibtex" | "biblatexml" | "ris" | "zoterordfxml" | "endnotexml" },
        attribute map_overwrite { "0" | "1" }?,
        attribute level { "user" | "style" | "driver" }?,
        map+
      }+
    }?,

    # labelalpha template specification
    element bcf:labelalphatemplate {
      attribute type { xsd:string }?, # per-type?
      element bcf:labelelement {
        attribute order { xsd:integer },
        element bcf:labelpart {          
          attribute final { "0" | "1" }?,
          attribute pad_char { xsd:string {minLength="1"}}?,
          attribute pad_side { "left" | "right" }?,
          attribute substring_width { xsd:integer | "v" | "vf" | "l" }?,
          attribute substring_fixed_threshold { xsd:integer }?,
          attribute substring_width_max { xsd:integer }?,
          attribute substring_side { "left" | "right" }?,
          attribute substring_compound { "0" | "1" }?,
          attribute ifnamecount { xsd:integer }?,
          attribute namecount { xsd:integer }?,
          attribute form { "original" | "translated" | "romanised" | "uniform" }?,
          xsd:string
        }+
      }+
    }+,

    # Cross-reference inheritance specifications
    element bcf:inheritance {
      # Defaults
      element bcf:defaults {
        # Whether to inherit all fields
        attribute inherit_all { "true" | "false" },
        # Should we overwrite the target field if it exists?
        attribute override_target { "true" | "false" },
        # Default inherit_all and override_target settings for entrytype source/target pairs
        element bcf:type_pair {
          attribute source { "*" | xsd:string {minLength="1"}},
          attribute target { "*" | xsd:string {minLength="1"}},
          attribute inherit_all { "true" | "false" }?,
          attribute override_target { "true" | "false" }?,
          empty
        }*
      },
      # An inheritance specification
      element bcf:inherit {
        # applies to these pairs of source/target entrytypes
        element bcf:type_pair {
          attribute source { "*" | xsd:string {minLength="1"}},
          attribute target { "*" | xsd:string {minLength="1"}},
          empty
        }+,
        # and here are the field specifications
        element bcf:field {
          (
            # either a "skip this field" specification
            # so we can say inherit all except certain fields OR ...
            (attribute source { xsd:string },
              attribute skip { "true" | "false" }) |
            # ... a source and target field with an optional override attribute
            (attribute source { xsd:string {minLength="1"}},
              attribute target { xsd:string {minLength="1"}},
              attribute override_target { "true" | "false" }?)
          ),
          empty
        }+
      }*
    },
    # noinit specification
    element bcf:noinits {
      element bcf:noinit {
        attribute value { xsd:string },
        empty
      }+
    }?,
    # nolabel specification
    element bcf:nolabels {
      element bcf:nolabel {
        attribute value { xsd:string },
        empty
      }+
    }?,
    # nosort specification
    element bcf:nosorts {
      element bcf:nosort {
        attribute field { xsd:string },
        attribute value { xsd:string },
        empty
      }+
    }?,
    # Global sorting specification
    sorting,
    # Data model specification
    element bcf:datamodel {
      # Valid entrytypes
      element bcf:entrytypes {
        element bcf:entrytype {
          # Some entrytypes should be completely skipped on output (XDATA etc.)
          attribute skip_output { "true" }?,
          text
        }+
      },
      # BibLaTeX field types. Biber uses this to determine how to output various types
      # to the .bbl
      element bcf:fields {
        element bcf:field {
          # fieldtype is "field" or "list"
          attribute fieldtype { "field" | "list" },
          # format is a specification of the format of the field. If not specified, field contents
          # are just as is. 
          attribute format { "xsv" }?,
          # datatype of field content
          attribute datatype { "literal" | "name" | "key" | "entrykey" | "date" | "verbatim" | "integer" | "range" | "code" | "uri" | "datepart" | "keyword" | "option" },
          # Are we allowed to output a null field value to the .bbl for this field?
          attribute nullok { "true" }?,
          # Should this field be skipped and not output to the .bbl?
          attribute skip_output { "true" }?,
          # Field can be used as a label? This auto-generates some defaults in biblatex
          attribute label { "true" }?,
          text
        }+
      },
      # Allowable fields for entrytypes
      # Only one specification per entrytype: even though it might be nice to have several 
      # so that one could share information, this would be hard to manage and confusing as it
      # not be visible in one place which fields were valid for an entrytype.
      element bcf:entryfields {
         element bcf:entrytype { text }*,
         element bcf:field { text }+
      }+,
      # Constraints on field (co-)existence and format
      element bcf:constraints {
        # Set of entrytypes that this constraint applies to
        # An entrytype can be specified in multiple constraints
        #
        element bcf:entrytype { text }*,
        # A constraint specification
        element bcf:constraint {
          (
            # Conditional constraints have an antecedent and consequent
            # both of which have a quantifier. This allows you to enforce
            # constraints like:
            #
            # if field a,b,c are all present then one of x,y,z must be
            # if one of field a,b,c are present then none of x,y,z must be
            # etc.
            (attribute type { "conditional" },
              element bcf:antecedent {
                attribute quant { "all" | "one" | "none"},
                element bcf:field { text }+
              },
              element bcf:consequent {
                attribute quant { "all" | "one" | "none"},
                element bcf:field { text }+
              }
            ) |
            # Datatype and format constraints
            (attribute type { "data" },
              # range* attributes are for limiting integer type range
              attribute datatype { "integer" | "isbn" | "issn" | "ismn" | "date" | "pattern" }?,
              attribute rangemin { xsd:int }?,
              attribute rangemax { xsd:int }?,
              attribute pattern { text }?,
              element bcf:field { text }+
            ) |
            # Mandatoriness constraints which say which fields must appear
            (attribute type { "mandatory" },
              (element bcf:field { text } |
                # An XOR set of fields so you can enforce:
                #
                # One (but not more) of fields a,b,c must exist
                element bcf:fieldxor {
                  element bcf:field { text }+
                } |
                # An OR set of fields so you can enforce:
                #
                # One (possibly more) of fields a,b,c must exist
                element bcf:fieldor {
                  element bcf:field { text }+
                }
                )+
              )
            )
          }*
        }+
      }?,
      # Section specifications
      secspec+,
      listspec+
    }

listspec = 
    element bcf:sortlist {
      attribute section { xsd:integer },
      attribute type { "entry" | "list" },
      attribute sortscheme { xsd:string {minLength="1"}},
      # name is only needed for list types
      attribute name { xsd:string {minLength="1"}},
      (filter | filteror )*,
      element bcf:sorting {
        # locale for entire sorting specification
        attribute locale { xsd:string {minLength="1"}}?,
        sort+
      }?
    }*


sorting = 
  element bcf:sorting {
    # locale for entire sorting specification
    attribute locale { xsd:string {minLength="1"}}?,
    # presort default strings for different entry types
    element bcf:presort {
      attribute type { text }?,
      text
    }+,
    # excludes of certain fields for sorting for specified types
    element bcf:sortexclusion {
      attribute type { text },
      element bcf:exclusion { text }+
    }*,
    sort+
  }

sort =
  # sort specification
  element bcf:sort {
    # order of this specification in the set of all sort specifications
    attribute order { xsd:integer },
    # Should we stop generating sorting information after this item?
    attribute final { "1" }?,
    # Sort ascending or descending
    attribute sort_direction { "ascending" | "descending" }?,
    # Sort case sensitive or not?
    attribute sortcase { "0" | "1" }?,
    # Sort upper before lower?
    attribute sortupper { "0" | "1" }?,
    # sortset specific override for locale
    attribute locale { xsd:string {minLength="1"}}?,
    # A sort item specification - a field or pseudo-field to get sort information from
    element bcf:sortitem {
      # order of this item in the set of all other item specifications
      attribute order { xsd:integer },
      # Just use a part of the item information for sorting?
      attribute substring_side { "left" | "right" }?,
      attribute substring_width { xsd:integer }?,
      # Pad the item information when sorting with it?
      attribute pad_side { "left" | "right" }?,
      attribute pad_width { xsd:integer }?,
      attribute pad_char { xsd:string { minLength = "1" maxLength = "1" } }?,
      attribute form { "original" | "translated" | "romanised" | "uniform" }?,
      text
    }+
  }+

# Section specification
secspec =
  # data sources
  element bcf:bibdata {
    # which sections the datafiles are for
    attribute section { xsd:integer },
    element bcf:datasource {
      attribute type { "file" },
      attribute datatype { "bibtex" | "biblatexml" | "ris" | "zoterordfxml" | "endnotexml" }?,
      xsd:anyURI
    }*
  }?,
  # citekeys or citekey sets in each section
  element bcf:section {
    attribute number { xsd:integer },
    element bcf:citekey {
      ( attribute type { "set" },
        attribute members { xsd:string {minLength="1"}},
        xsd:string {minLength="1"}) |
      ( attribute order { xsd:integer },
        xsd:string {minLength="1"} )
    }*
  }

filteror = element bcf:filteror {
             filter+
           }

filter = element bcf:filter {
           attribute type { "type" | "nottype" | "subtype" | "notsubtype"
                         | "keyword" | "notkeyword" | "field" | "notfield" },
           xsd:string {minLength="1"}
         }

# option definitions
# use<name> options are dynamically determined from data model
usenames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { xsd:string {pattern = "use.*"} },
    element bcf:value { "0" | "1" }
  }+
useprefix =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "useprefix" },
    element bcf:value { "0" | "1" }
  }
labelalpha =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "labelalpha" },
    element bcf:value { "0" | "1" }
  }
labeltitle =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "labeltitle" },
    element bcf:value { "0" | "1" }
  }
labeltitlespec =
  element bcf:option {
    attribute type { "multivalued" },
    element bcf:key { "labeltitlespec" },
    element bcf:value {
      attribute order { xsd:integer },
      attribute form { "original" | "translated" | "romanised" | "uniform" }?,
      attribute lang { text }?,
      text
    }+
  }
labeltitleyear =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "labeltitleyear" },
    element bcf:value { "0" | "1" }
  }
labeldate =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "labeldate" },
    element bcf:value { "0" | "1" }
  }
labeldatespec =
  element bcf:option {
    attribute type { "multivalued" },
    element bcf:key { "labeldatespec" },
    element bcf:value {
      attribute order { xsd:integer },
      attribute type { "field" | "string" },
      text
    }+
  }
singletitle =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "singletitle" },
    element bcf:value { "0" | "1" }
  }
skipbib =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "skipbib" },
    element bcf:value { "0" | "1" }
  }
skiplab =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "skiplab" },
    element bcf:value { "0" | "1" }
  }
skiplos =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "skiplos" },
    element bcf:value { "0" | "1" }
  }
skipbiblist =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "skipbiblist" },
    element bcf:value { "0" | "1" }
  }
# 0 = do not provide uniquelist information
# 1 = disambiguate lists regardless of year
# 2 = disambiguate lists only when year is the same
uniquelist =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "uniquelist" },
    element bcf:value { "0" | "1" | "2" }
  }
# 0 = do not provide uniquename information
# 1 = disambiguate with initials, only up to maxcitenames/uniquelist
# 2 = disambiguate with full name or initials, only up to maxcitenames/uniquelist
# 3 = disambiguate with initials, ignore maxcitenames/uniquelist
# 4 = disambiguate with full name or initials, ignore maxcitenames/uniquelist
# 5 = disambiguate with initials, only between identical lists in different entries
# 6 = disambiguate with full name or initials, only between identical lists in different entries
uniquename =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "uniquename" },
    element bcf:value { "0" | "1" | "2" | "3" | "4" | "5" | "6" }
  }
maxitems =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "maxitems" },
    element bcf:value { xsd:integer }
  }
maxbibnames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "maxbibnames" },
    element bcf:value { xsd:integer }
  }
maxalphanames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "maxalphanames" },
    element bcf:value { xsd:integer }
  }
maxcitenames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "maxcitenames" },
    element bcf:value { xsd:integer }
  }
minitems =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "minitems" },
    element bcf:value { xsd:integer }
  }
minbibnames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "minbibnames" },
    element bcf:value { xsd:integer }
  }
minalphanames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "minalphanames" },
    element bcf:value { xsd:integer }
  }
mincitenames =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "mincitenames" },
    element bcf:value { xsd:integer }
  }
sortlocale =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortlocale" },
    element bcf:value { text }
  }
sortscheme =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortscheme" },
    element bcf:value { text }
  }
labelnamespec =
  element bcf:option {
    attribute type { "multivalued" },
    element bcf:key { "labelnamespec" },
    element bcf:value {
      attribute order { xsd:integer },
      attribute form { "original" | "translated" | "romanised" | "uniform" }?,
      attribute lang { text }?,
      text
    }+
  }
mincrossrefs =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "mincrossrefs" },
    element bcf:value { xsd:integer }
  }
debug =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "debug" },
    element bcf:value { "0" | "1" }
  }
wrapline =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "wrapline" },
    element bcf:value { xsd:integer }
  }  
output_encoding =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "output_encoding" },
    element bcf:value { text }
  }
input_encoding =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "input_encoding" },
    element bcf:value { text }
  }
sortcase =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortcase" },
    element bcf:value { "0" | "1" }
  }
sortfirstinits =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortfirstinits" },
    element bcf:value { "0" | "1" }
  }
alphaothers =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "alphaothers" },
    element bcf:value {
      xsd:normalizedString { pattern = "\S+" }
    }
  }
sortupper = 
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortupper" },
    element bcf:value { "0" | "1" }
  }
sortalphaothers =
  element bcf:option {
    attribute type { "singlevalued" },
    element bcf:key { "sortalphaothers" },
    element bcf:value {
      xsd:normalizedString { pattern = "\S+" }
    }
  }

map =
  element bcf:map {
    attribute map_overwrite { "0" | "1" }?,
    element bcf:per_datasource { xsd:string {minLength="1"} }*,
    element bcf:per_type { xsd:string {minLength="1"} }*,
    element bcf:map_step {
      (
        (
          attribute map_entry_null { "1" }
        ) |
        (
          attribute map_type_source { xsd:string {minLength="1"} },
          attribute map_type_target { xsd:string {minLength="1"} }?,
          attribute map_final { "1" }?
        ) |
        (
          attribute map_field_source { xsd:string {minLength="1"} },
          attribute map_field_target { xsd:string {minLength="1"} }?,
          attribute map_final { "1" }?,
          attribute map_match { xsd:string {minLength="1"} }?,
          attribute map_notmatch { xsd:string {minLength="1"} }?,
          attribute map_replace { xsd:string {minLength="1"} }?
        ) |
        (
          attribute map_field_set { xsd:string {minLength="1"} },
          attribute map_append { "1" }?,
          attribute map_final { "1" }?,
          ( attribute map_null { "1" } |
            attribute map_origfield { "1" } |
            attribute map_origfieldval { "1" } |
            attribute map_origentrytype { "1" } |
            attribute map_field_value { xsd:string {minLength="1"} } )
        )
      ),
      empty
    }+
  }
# Copyright 2009-2015 François Charette and Philip Kime, all rights reserved.

# This code is free software.  You can redistribute it and/or
# modify it under the terms of the Artistic License 2.0.

# This program is distributed in the hope that it will be useful,
# but without any warranty; without even the implied warranty of
# merchantability or fitness for a particular purpose.