=head1 NAME

bt_macros - accessing and manipulating the btparse macro table

=head1 SYNOPSIS

   void bt_add_macro_value (AST *  assignment,
                            btshort options);
   void bt_add_macro_text (char * macro,
                           char * text,
                           char * filename,
                           int    line);

   void bt_delete_macro (char * macro);
   void bt_delete_all_macros (void);

   int bt_macro_length (char *macro);
   char * bt_macro_text (char * macro,
                         char * filename,
                         int line);

=head1 DESCRIPTION

B<btparse> maintains a single table of all macros (abbreviations)
encountered while parsing BibTeX entries.  It updates this table
whenever it encounters a "macro definition" (C<@string>) entry, and
refers to it whenever a macro is used in an entry and needs to be
expanded.  (Macros are not necessarily expanded on input, although this
is the default.  See L<bt_postprocess>.)  Macro definitions are only
cleared when B<btparse>'s global cleanup function, C<bt_cleanup()>, is
called.  Thus, unless you explicitly call C<bt_delete_macro()> or
C<bt_delete_all_macros()>, macro definitions persist for as long as you
use the library---usually, the lifetime of your process.

=head1 FUNCTIONS

You can use the following functions to add macros, delete them, and
query their values---thus interfering with B<btparse>'s normal operation
on the fly.

=over 4

=item bt_add_macro_text ()

   void bt_add_macro_text (char * macro,
                           char * text,
                           char * filename,
                           int    line);

Defines a new macro, or redefines an old one.  C<macro> is the name of
the macro, and C<text> is the text it should expand to.  C<filename> and
C<line> are just used to generate any warnings about the macro
definition; if they don't apply, specify C<NULL> for C<filename> and
C<0> for C<line>.  The only such warning occurs when you redefine an old
macro: its value is overridden, and C<bt_add_macro_text()> issues a
warning saying so.  

For instance, when parsing this macro definition entry:

   @string{fubar = "Fouled Up Beyond All Recognition"}

the library (in particular, the post-processing code called after an
entry is successfully parsed) will ultimately do this:

   bt_add_macro_text ("fubar", "Fouled Up Beyond All Recognition",
                      filename, line);

This in turn will cause the macro C<fubar> to be expanded appropriately
whenever the post-processing code sees it in any future entries.

=item bt_add_macro_value ()

   void bt_add_macro_value (AST *  assignment,
                            btshort options);

This function is mainly for internal use by the library, but it's
available to you if you ever find yourself with a little bit of AST
representing a macro definition, and you want to set the macro yourself
(rather than letting the library's post-processing code take care of it
for you).  C<assignment> must be an AST node as returned by
C<bt_next_field()>.  Unlike most other B<btparse> functions that take an
C<options> argument, C<options> here tells how the value in
C<assignment> was post-processed.  This is needed because macro values
have to be processed in a special way to be valid in future expansions;
if this one wasn't processed like that, C<bt_add_macro_value()> will do
it for you.  If you don't know how the value was post-processed, just
supply C<0> for C<options>---that's guaranteed to describe something
different from "the right way" for macros, so the post-processing will
be done correctly.

The processing done to macro values is mainly to ensure that we can get
away with storing just a string in the macro table: macros invoked by
the macro are themselves expanded, and all sub-strings are concatenated.
For instance, if B<btparse> parses these entries:

   @string{and = " and "}
   @string{jim_n_bob = "James Smith" # and # "Bob Jones"}

then the value stored for C<jim_n_bob> should obviously be the string
C<"James Smith and Bob Jones">.  To ensure this, B<btparse> has to
process the value of C<and> differently from most BibTeX strings: in
particular, whitespace is I<not> collapsed before the string is stored.
That way, the correct value, C<" and ">, is interpolated into the value
of C<jim_n_bob>.  Thus, all macro values have sub-macros expanded and
strings concatenated before they are stored, but whitespace is not
collapsed until the macro is used in a regular entry.

This function calls C<bt_add_macro_text()>, so the same proviso about
redefining old macros applies---a warning will be issued, and the old
value lost.

=item bt_delete_macro ()

   void bt_delete_macro (char * macro);

Deletes a macro from the macro table.  If C<macro> isn't defined,
takes no action.

=item bt_delete_all_macros ()

   void bt_delete_all_macros (void);

Deletes all macros from the macro table.

=item bt_macro_length ()

   int bt_macro_length (char *macro);

Returns the length of a macro's expansion text.  If the macro is
undefined, returns 0; no warning is issued.

=item bt_macro_text ()

   char * bt_macro_text (char * macro,
                         char * filename,
                         int line);

Returns the expansion text of a macro.  If the macro is not defined,
issues a warning and returns C<NULL>.  C<filename> and C<line> are used
for generating this warning; if they don't apply (i.e. you're not
expanding the macro as a result of finding it in some file), supply
C<NULL> for C<filename> and C<0> for C<line>.

=back

=head1 SEE ALSO

L<btparse>

=head1 AUTHOR

Greg Ward <gward@python.net>
