# NAME

Math::SymbolicX::ParserExtensionFactory - Generate parser extensions

# SYNOPSIS

```
use Math::Symbolic qw/parse_from_string/;
# This will extend all parser objects in your program:
use Math::SymbolicX::ParserExtensionFactory (
functionname => sub {
my $argumentstring = shift;
my $result = construct_some_math_symbolic_tree( $argumentstring );
return $result;
},
anotherfunction => sub {
...
},
);
# ...
# Later in your code
my $formula = parse_from_string('variable * 4 * functionname(someargument)');
# use $formula as a Math::Symbolic object.
# Refer to Math::SymbolicX::BigNum (arbitrary precision arithmetic
# support through the Math::Big* modules) or to
# Math::SymbolicX::ComplexNumbers (complex number support) for examples.
# Alternative: modify a single parser object only:
my $parser = Math::Symbolic::Parser->new();
Math::SymbolicX::ParserExtensionFactory->add_private_functions(
$parser,
fun_function => sub {...},
my_function => sub {...},
...
);
```

# DESCRIPTION

This module provides a simple way to extend the Math::Symbolic parser with arbitrary functions that return any valid Math::Symbolic tree. The return value of the function call is inserted into the complete parse tree at the point at which the function call is parsed. Familiarity with the Math::Symbolic module will be assumed throughout the documentation.

This module is not object oriented. It does not export anything. You should not call any subroutines directly nor should you modify any class data directly. The complete interface is the call to `use Math::SymbolicX::ParserExtensionFactory`

and its arguments. The reason for the long module name is that you should not have to call it multiple times in your code because it modifies the parser for good. It is intended to be a pain to type. :-)

The aim of the module is to allow for hooks into the parser without modifying the parser yourself because that requires rather in-depth knowledge of the module code. By specifying key => value pairs of function names and function implementations (code references) as arguments to the use() call of the module, this module extends the parser that is stored in the `$Math::Symbolic::Parser`

variable with the specified functions and whenever "`yourfunction(any argument string with balanced parenthesis)`

" occurs in the code, the subroutine reference is called with the argument string as argument.

The subroutine is expected to return any Math::Symbolic tree. That means, as of version 0.506 of Math::Symbolic, a Math::Symbolic::Operator, a Math::Symbolic::Variable, or a Math::Symbolic::Constant object. The returned object will be incorporated into the Math::Symbolic tree that results from the parse at the exact position at which the custom function call was parsed.

Please note that the usage of this module will be quite slow at compile time because it has to regenerate the complete Math::Symbolic parser the first time you use this module in your code. The run time performance penalty should be low, however.

# FUNCTIONS

## add_private_functions

Callable as class method or function. First argument must be the parser object to modify (either a Parse::RecDescent or a Parse::Yapp based Math::Symbolic parser), followed by key/value pairs of function names and code refs (implementations).

Modifies only the parser passed in as first argument. For an example, see synopsis above.

# CAVEATS

Since version 2.00 of this module, the old, broken parsing of the argument string which would fail on nested, unescaped parenthesis was replaced by a better routine which will correctly parse nested pairs of parenthesis.

On the flip side, if the argument string contains unmatched parenthesis, the parse will fail. Examples:

` "myfunction(foo(bar)" # fails because missing closing parenthesis`

Escaping of parenthesis in the argument string **is no longer supported**.

# AUTHOR

Copyright (C) 2003-2009 Steffen Mueller

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

You may contact the author at symbolic-module at steffen-mueller dot net

Please send feedback, bug reports, and support requests to the Math::Symbolic support mailing list: math-symbolic-support at lists dot sourceforge dot net. Please consider letting us know how you use Math::Symbolic. Thank you.

If you're interested in helping with the development or extending the module's functionality, please contact the developers' mailing list: math-symbolic-develop at lists dot sourceforge dot net.

# SEE ALSO

New versions of this module can be found on http://steffen-mueller.net or CPAN.

Also have a look at Math::Symbolic, and at Math::Symbolic::Parser

Refer to Math::SymbolicX::BigNum (arbitrary precision arithmetic support through the Math::Big* modules) or to Math::SymbolicX::ComplexNumbers (complex number support) for examples.