1Biber(3)              User Contributed Perl Documentation             Biber(3)
2
3
4

NAME

6       Biber - main module for biber, a bibtex replacement for users of
7       biblatex
8

SYNOPSIS

10           use Biber;
11           my $biber = Biber->new();
12           $biber->parse_ctrlfile("example.bcf");
13           $biber->prepare;
14

METHODS

16   new
17           Initialize the Biber object, optionally passing named options as arguments.
18
19   display_problems
20          Output summary of warnings/errors before exit
21
22   biber_tempdir
23           my $sections= $biber->biber_tempdir
24
25           Returns a File::Temp directory object for use in various things
26
27   sections
28           my $sections= $biber->sections
29
30           Returns a Biber::Sections object describing the bibliography sections
31
32   add_sections
33           Adds a Biber::Sections object. Used externally from, e.g. biber
34
35   datalists
36           my $datalists= $biber->datalists
37
38           Returns a Biber::DataLists object describing the bibliography sorting lists
39
40   set_output_obj
41           Sets the object used to output final results
42           Must be a subclass of Biber::Output::base
43
44   get_preamble
45           Returns the current preamble as an array ref
46
47   get_output_obj
48           Returns the object used to output final results
49
50   set_current_section
51           Sets the current section number that we are working on to a section number
52
53   get_current_section
54           Gets the current section number that we are working on
55
56   tool_mode_setup
57         Fakes parts of the control file for tool mode
58
59   parse_ctrlfile
60           This method reads the control file
61           generated by biblatex to work out the various biblatex options.
62           See Constants.pm for defaults and example of the data structure being built here.
63
64   process_setup
65          Place to put misc pre-processing things needed later
66
67   process_setup_tool
68          Place to put misc pre-processing things needed later for tool mode
69
70   resolve_alias_refs
71         Resolve aliases in xref/crossref/xdata which take keys as values to their real keys
72
73         We use set_datafield as we are overriding the alias in the datasource
74
75   process_citekey_aliases
76        Remove citekey aliases from citekeys as they don't point to real
77        entries.
78
79   instantiate_dynamic
80           This instantiates any dynamic entries so that they are available
81           for processing later on. This has to be done before most all other
82           processing so that when we call $section->bibentry($key), as we
83           do many times in the code, we don't die because there is a key but
84           no Entry object.
85
86   resolve_xdata
87           Resolve xdata entries
88
89   cite_setmembers
90           Promotes set member to cited status
91
92   preprocess_sets
93           $biber->preprocess_sets
94
95           This records the set information for use later
96
97   process_interentry
98           $biber->process_interentry
99
100           This does several things:
101           1. Ensures proper inheritance of data from cross-references.
102           2. Ensures that crossrefs/xrefs that are directly cited or cross-referenced
103              at least mincrossrefs/minxrefs times are included in the bibliography.
104
105   validate_datamodel
106         Validate bib data according to a datamodel
107         Note that we are validating the internal Biber::Entries
108         after they have been created from the datasources so this is
109         datasource neutral, as it should be. It is here to enforce
110         adherence to what biblatex expects.
111
112   process_namedis
113           Generate name strings and disambiguation schema. Has to be in the context
114           of a data list (reference context) because uniquenametemplate can be specified
115           per-list/context
116
117   postprocess_sets
118         Adds required per-entry options etc. to sets
119
120   process_entries_static
121         Processing of entries which is not list-specific and which can therefore
122         insert data directly into entries
123
124   process_entries_pre
125           Main processing operations, to generate metadata and entry information
126           This method is automatically called by C<prepare>.
127           Here we generate the "namehash" and the strings for
128           "labelname", "labelyear", "labelalpha", "sortstrings", etc.
129           Runs prior to uniqueness processing
130
131   process_entries_post
132           More processing operations, to generate things which require uniqueness
133           information like namehash
134           Runs after uniqueness processing
135
136   process_entries_final
137           Final processing operations which depend on all previous processing
138
139   process_uniqueprimaryauthor
140           Track seen primary author base names for generation of uniqueprimaryauthor
141
142   process_workuniqueness
143           Track seen work combination for generation of singletitle, uniquetitle, uniquebaretitle and
144           uniquework
145
146   process_extradate
147           Track labelname/date parts combination for generation of extradate
148
149   process_extraname
150           Track labelname only for generation of extraname
151
152   process_extratitle
153           Track labelname/labeltitle combination for generation of extratitle
154
155   process_extratitleyear
156           Track labeltitle/labelyear combination for generation of extratitleyear
157
158   process_sets
159           Postprocess set entries
160
161           Checks for common set errors and enforces 'dataonly' for set members.
162           It's not necessary to set skipbib, skipbiblist in the OPTIONS field for
163           the set members as these are automatically set by biblatex due to the \inset
164
165   process_nocite
166           Generate nocite information
167
168   process_labelname
169           Generate labelname information.
170
171   process_labeldate
172           Generate labeldate information, including times
173
174   process_labeltitle
175         Generate labeltitle
176
177         Note that this is not conditionalised on the biblatex "labeltitle"
178         as labeltitle should always be output since all standard styles need it.
179         Only extratitle is conditionalised on the biblatex "labeltitle" option.
180
181   process_fullhash
182           Generate fullhash
183
184   process_namehash
185           Generate namehash
186
187   process_pername_hashes
188           Generate per_name_hashes
189
190   process_visible_names
191           Generate the visible name information.
192           This is used in various places and it is useful to have it generated in one place.
193
194   process_labelalpha
195           Generate the labelalpha and also the variant for sorting
196
197   process_extraalpha
198           Generate the extraalpha information
199
200   process_presort
201           Put presort fields for an entry into the main Biber bltx state
202           so that it is all available in the same place since this can be
203           set per-type and globally too.
204
205   process_lists
206           Process a bibliography list
207
208   check_list_filter
209           Run an entry through a list filter. Returns a boolean.
210
211   generate_sortdataschema
212           Generate sort data schema for Sort::Key from sort spec like this:
213
214         spec   => [
215                     [undef, { presort => {} }],
216                     [{ final => 1 }, { sortkey => {} }],
217                     [
218                       {'sort_direction'  => 'descending'},
219                       { sortname => {} },
220                       { author => {} },
221                       { editor => {} },
222                       { translator => {} },
223                       { sorttitle => {} },
224                       { title => {} },
225                     ],
226                     [undef, { sortyear => {} }, { year => {} }],
227                     [undef, { sorttitle => {} }, { title => {} }],
228                     [undef, { volume => {} }, { "0000" => {} }],
229                   ],
230
231   generate_sortinfo
232           Generate information for sorting
233
234   uniqueness
235           Generate the uniqueness information needed when creating .bbl
236
237   create_uniquename_info
238           Gather the uniquename information as we look through the names
239
240           What is happening in here is the following:
241           We are registering the number of occurrences of each name, name+init and fullname
242           within a specific context. For example, the context is "global" with uniquename < 5
243           and "name list" for uniquename=5 or 6. The keys we store to count this are the most specific
244           information for the context, so, for uniquename < 5, this is the full name and for
245           uniquename=5 or 6, this is the complete list of full names. These keys have values in a hash
246           which are ignored. They serve only to accumulate repeated occurrences with the context
247           and we don't care about this and so the values are a useful sinkhole for such repetition.
248
249           For example, if we find in the global context a base name "Smith" in two different entries
250           under the same form "Alan Smith", the data structure will look like:
251
252           {Smith}->{global}->{Alan Smith} = 2
253
254           We don't care about the value as this means that there are 2 "Alan Smith"s in the global
255           context which need disambiguating identically anyway. So, we just count the keys for the
256           base name "Smith" in the global context to see how ambiguous the base name itself is. This
257           would be "1" and so "Alan Smith" would get uniquename=0 because it's unambiguous as just
258           "Smith".
259
260           The same goes for "minimal" list context disambiguation for uniquename=5 or 6.
261           For example, if we had the base name "Smith" to disambiguate in two entries with labelname
262           "John Smith and Alan Jones", the data structure would look like:
263
264           {Smith}->{Smith+Jones}->{John Smith+Alan Jones} = 2
265
266           Again, counting the keys of the context for the base name gives us "1" which means we
267           have uniquename=0 for "John Smith" in both entries because it's the same list. This also
268           works for repeated names in the same list "John Smith and Bert Smith". Disambiguating
269           "Smith" in this:
270
271           {Smith}->{Smith+Smith}->{John Smith+Bert Smith} = 2
272
273           So both "John Smith" and "Bert Smith" in this entry get uniquename=0 (of course, as long as
274           there are no other "X Smith and Y Smith" entries where X != "John" or Y != "Bert").
275
276           The values from biblatex.sty:
277
278           false   = 0
279           init    = 1
280           true    = 2
281           full    = 2
282           allinit = 3
283           allfull = 4
284           mininit = 5
285           minfull = 6
286
287   generate_uniquename
288          Generate the per-name uniquename values using the information
289          harvested by create_uniquename_info()
290
291   create_uniquelist_info
292           Gather the uniquelist information as we look through the names
293
294   generate_uniquelist
295          Generate the per-namelist uniquelist values using the information
296          harvested by create_uniquelist_info()
297
298   generate_contextdata
299           Generate information for data which may changes per datalist
300
301   generate_singletitle
302           Generate the singletitle field, if requested. The information for generating
303           this is gathered in process_workuniqueness()
304
305   generate_uniquetitle
306           Generate the uniquetitle field, if requested. The information for generating
307           this is gathered in process_workuniqueness()
308
309   generate_uniquebaretitle
310           Generate the uniquebaretitle field, if requested. The information for generating
311           this is gathered in process_workuniqueness()
312
313   generate_uniquework
314           Generate the uniquework field, if requested. The information for generating
315           this is gathered in process_workuniqueness()
316
317   generate_uniquepa
318           Generate the uniqueprimaryauthor field, if requested. The information for generating
319           this is gathered in create_uniquename_info()
320
321   sort_list
322           Sort a list using information in entries according to a certain sorting template.
323           Use a flag to skip info messages on first pass
324
325   preprocess_options
326          Preprocessing for options. Used primarily to perform process-intensive
327          operations which can be done once instead of inside dense loops later.
328
329   prepare
330           Do the main work.
331           Process and sort all entries before writing the output.
332
333   prepare_tool
334           Do the main work for tool mode
335
336   fetch_data
337           Fetch citekey and dependents data from section datasources
338           Expects to find datasource packages named:
339
340           Biber::Input::<type>::<datatype>
341
342           and one defined subroutine called:
343
344           Biber::Input::<type>::<datatype>::extract_entries
345
346           which takes args:
347
348           1: Biber object
349           2: Datasource name
350           3: Reference to an array of cite keys to look for
351
352           and returns an array of the cite keys it did not find in the datasource
353
354   get_dependents
355         Get dependents of the entries for a given list of citekeys. Is called recursively
356         until there are no more dependents to look for.
357
358   remove_undef_dependent
359           Remove undefined dependent keys from an entry using a map of
360           dependent keys to entries
361
362   _parse_sort
363          Convenience sub to parse a .bcf sorting section and return nice
364          sorting object
365
366   _filedump and _stringdump
367           Dump the biber object with Data::Dump for debugging
368

AUTHORS

370       Francois Charette, "<firmicus at ankabut.net>" Philip Kime "<philip at
371       kime.org.uk>"
372

BUGS

374       Please report any bugs or feature requests on our Github tracker at
375       <https://github.com/plk/biber/issues>.
376
378       Copyright 2009-2018 Francois Charette and Philip Kime, all rights
379       reserved.
380
381       This module is free software.  You can redistribute it and/or modify it
382       under the terms of the Artistic License 2.0.
383
384       This program is distributed in the hope that it will be useful, but
385       without any warranty; without even the implied warranty of
386       merchantability or fitness for a particular purpose.
387
388
389
390perl v5.30.1                      2020-01-28                          Biber(3)
Impressum