# Difference between revisions of "ParserFunctions"

The MediaWiki extension ParserFunctions is a collection of parser functions (note the difference between the name of the collection, and the general term). These parser functions have a hash character in front of the function name, so they typically have the syntax:

Šablona:ft

Please note that ParserFunctions are unavailable in some MediaWiki installations, check out Special:Version below Parser hooks, individual functions such as expr and switch are listed below Parser function hooks.

## Funkce

Toto rozšíření definuje deset funkcí: expr, if, ifeq, ifexist, ifexpr, iferror, switch, time, rel2abs, a titleparts.

### #expr:

The expr function computes mathematical expressions based on permutations of numbers (or variables/parameters that translate to numbers) and operators. It does not recognize strings (use ifeq below instead). The accuracy and format of numeric results varies with the server's operating system.

Operators are listed below. In a complex expression, operators are evaluated from left to right with the following precedence (explained in more detail in Help:Calculation):

1. grouping (parentheses);
2. unary (+/- signs and NOT);
3. multiplicative (*, /, div, mod);
4. additive (+ and -);
5. round;
6. comparative (=, !=, <, >, etc.);
7. logical AND;
8. logical OR.

When evaluating as boolean, "0" is considered false and any other non-space value is true (boolean true is represented as "1").

Decimal numbers use "." as a decimal point (`formatnum:` can be used to change the decimal point to a comma for the appropriate locales). Scientific notation with E plus exponent is meanwhile supported also on input for expressions (see Help:Calculation).

Operátor Operace Příklad Výsledek
none Šablona:ft 1.2345678901234E+14
Šablona:ft 1.0E-6
Arithmetic
+ Unary positive sign Šablona:ft 210
- Unary negative sign Šablona:ft 210
* Multiplication Šablona:ft 210
/
div
Division Šablona:ft
Šablona:ft
4.2857142857143
4.2857142857143
+ Addition Šablona:ft 37
- Subtraction Šablona:ft 23
Logic
not Unary NOT
logical NOT
Šablona:ft
Šablona:ft
7
7
and Logical AND 0
or Logical OR 1
Comparison
= Equality (numerical & logical) Šablona:ft 0
<>
!=
Inequality, logical exclusive or Šablona:ft
Šablona:ft
1
1
< Less than 0
> Greater than 1
<= Less than or equal to 0
>= Greater than or equal to 1
Other
( ) Grouping operators Šablona:ft 259
mod "Modulo" truncates the numbers to whole numbers, divides the left number by the right, and returns the remainder that could not be divided.
Note: div and mod are different from all programming languages.
Šablona:ft
Šablona:ft
Šablona:ft
2
-2
0
round Rounds off the number on the left to the power of 1/10 given on the right. Šablona:ft
Šablona:ft
Šablona:ft
Šablona:ft
4.2857
4.3
1900
-3
trunc Removes all decimals. Šablona:ft
Šablona:ft
1
-1
floor Rounds off a decimal number to the closest integer that is less than or equal to the given number. Šablona:ft
Šablona:ft
1
-2
ceil Rounds off a decimal number to the closest integer that is more than or equal to the given number. Šablona:ft
Šablona:ft
2
-1

### #if:

Syntaxe

```{{#if: <Výraz> | <Kód pro pravdivý výraz> | <Kód pro nepravdivý výraz> }}
```
```{{#if: <Výraz> | <Kód pro pravdivý výraz>}}
```

Funkce `if` je klasický podmínkový výraz if-then-else. Výraz bude vždy True, pokud nebude jeho výsledkem mezera nebo prázdné místo.

 ```{{#if: něco | něco je tady | něco tu není}} ``` něco je tady ```{{#if: 0 | řetězec je tady | řetězec tu není}} ``` řetězec je tady ```{{#if: | výraz nevrací nic | výraz vrací prázdné místo }} ``` výraz vrací prázdné místo
 Výsledek výrazu je vždy interpretován jako textový řetězec, tj. výsledek matematické funkce bude vždy pravdivý, i za předpokladu že vrátí nulu! Stejně tak funkce if nerozpozná ani nepředaný parametr v šabloně. Pro takové případy musíte použít funkci #ifexpr.

### #ifeq:

The `ifeq` function compares two strings or numbers, and returns the second argument if they are equal and the third argument if not equal (either or both may be blank, and the code-if-not-equal argument can be omitted entirely).

Comparison of strings is case-sensitive (for example, A != a). If both strings can be interpreted numerically, they will be compared numerically (for example, 01 = 1); To force a string-based comparison, add non-numerical characters (such as quotes `"`) to both compared arguments.

It is possible to distinguish between undefined and empty template parameters by comparing default values (if the parameter is defined, it will overwrite the default value even if blank):

Issues:

• Text between <nowiki> tags is temporarily replaced by a unique code. This affects comparisons: Šablona:ft returns "not equal".

### #ifexist:

Šablona:ft returns one of two results based on whether or not a particular page exists.

```Šablona:ft
```

The usual case-sensitivity applies: if a page exists then also a non-canonical name for that page gives a positive result. E.g. on Meta:

Šablona:ft gives RFC 3092, because Bugs exists
Šablona:ft gives RFC 3092, because bugs is in canonical form the existing Bugs
Šablona:ft gives RFC 3092 because BUGS does not exist
Šablona:ft gives Oops although m:Help:Calculation exists, because of the interwiki prefix.

The first parameter is the title to check for, the second is the positive result, and the third, the negative result. If the parameter passed does not produce a valid title object, then the result is negative.

Šablona:tim gives the same result, except that the result is positive for an interwiki link. You can also handle an interwiki link differently with Šablona:tim.

Šablona:ft doesn't handle relative paths (like '../foo'), for that, use it in combination of Šablona:ft.

The page where {{#ifexist:foo}} appears is listed on Special:Whatlinkshere/foo (as a page which links to foo), see below.

On Wikimedia wikis there is a maximum for the number of distinct pages for which #ifexist is called on a page. A call of #ifexist after a transclusion of the same page does not require an extra database query and is therefore not counted. A call beyond the maximum returns "false". The html-source of each page shows the counted number of calls, as well as the maximum. The maximum is currently 500, and it has been announced that this will be lowered to 100. [1].

Šablona:ft can correctly check Special pages as well:

Šablona:ft gives works
Šablona:ft gives doesn't work

### #ifexpr:

Syntaxe

```{{#if: <matematická funkce> | <Kód pro nenulový výsledek> | <Kód pro výsledek který je nulový či prázdný> }}
```
```{{#if: <matematická funkce> | <Kód pro nenulový výsledek>}}
```

Funkce `ifexpr` je matematickou obdobou funkce `#if:`, která vrací odpovídající kód na základě aritmetického vyhodnocení výsledku matematické funkce (srovnej s funkcí `#if:`, která nulu i každé jiné číslo vždy interpretuje jako řetězec). Syntaxe pro zápis matematické funkce je stejná jako u funkce `#expr:`

 Je 10 větší než 9? ```{{#ifexpr: 10 > 9|ano|ne}} ``` Výsledek funkce: ano

Funkce `ifexpr` lze využít v šablonách při kontrole zda použitá proměnná, nezůstala prázdná.

 Má jmenný prostor s ID = 0 nějaký název? ```{{#ifexpr: {{ns:0}}|Ano|'''Ne'''}} ``` Ne ```{{#ifexpr: {{ns:0}}||'''Ne'''}} ``` Ne Obsahuje Kategorie:Help nějaké stránky? ```{{#ifexpr: {{PAGESINCATEGORY:Help}}|'''Ano''' - {{PAGESINCATEGORY:Help}}|Ne - {{PAGESINCATEGORY:Help}}}} ``` Ne - 0 ```{{#ifexpr: {{PAGESINCATEGORY:Help}}||Ne - {{PAGESINCATEGORY:Help}}}} ``` Ne - 0 Obsahuje Kategorie:Nápověda nějaké stránky? ```{{#ifexpr: {{PAGESINCATEGORY:Nápověda}}|'''Ano''' - {{PAGESINCATEGORY:Nápověda}}|Ne - {{PAGESINCATEGORY:Nápověda}}}} ``` Ano - 33 ```{{#ifexpr: {{PAGESINCATEGORY:Nápověda}}|'''Ano - {{PAGESINCATEGORY:Nápověda}}'''}} ``` Ano - 33
 V příkladech jsou použity systémové proměnné `{{ns}}` která vrací lokalizované názvy jmenných prostorů podle jejich ID ( Hlavní jmenný prostor s nulovým ID žádný název nemá, proto šablona vrací prázdný výsledek) a `{{PAGEINCATEGORY}}`, která vrací počet stránek zařazených do příslušné kategorie. V šablonách může být místo těchto systémových proměnných použita předaná proměnná a pomocí této funkce lze zkontrolovat zdali byl do ní předaný nějaký obsah.
 Pro zjišťování shody dvou čísel (tj. zda je hodnota A stejná jako hodnota B ) nepoužívejte tuto funkci, ale funkci `#ifeq:`

### #switch:

`switch` compares a single value against multiple others, returning a string if a match is found. The syntax is basically:

```Šablona:ft begin <comparison value>
| <value1> = <result1>
| <value2> = <result2>
| ...
| <valuen> = <resultn>
| <default result>
Šablona:ft end
```

`switch` will search through each value passed until a match is found with the comparison value. When found, the result for that value is returned (the text string after the equal sign). If no match is found, but the last item has no equal sign in it, it will be returned as the default result. If your default result must have an equal sign, you may use `#default`:

```Šablona:ft begin <comparison value>
| <value> = <result>
| #default = <default result>
Šablona:ft end
```

Note that it's also possible to have "fall through" for values (reducing the need to duplicate results). For example:

```Šablona:ft begin <comparison value>
| <value1>
| <value2>
| <value3> = <result1, 2, 3>
| ...
| <valuen> = <resultn>
| <default result>
Šablona:ft end
```

Note how value1 and value2 contain no equal sign. If they're matched, they are given the result for value3 (that is, whatever is in result3).

As for #ifeq: the comparison is numerical where possible:
Šablona:ft gives Yes
Šablona:ft gives No
The matched value can be empty, therefore the following constructs are equivalent:
Šablona:ft gives empty
Šablona:ft gives empty

Comparison of strings is case-sensitive:

Šablona:ft gives UPPER
Šablona:ft gives UPPER
Šablona:ft gives lower

This is not to be confused with the fact that parser function names are case-insensitive:

Šablona:ft gives UPPER

To have the #switch statement be case-insensitive, use the construct {{lc:}} or {{uc:}}

Šablona:ft gives lower
Šablona:ft gives lower
Šablona:ft gives lower

This is usually used in templates, when you want to have case-insensitivity on in param values:

```Šablona:ft begin Šablona:ft sub
| a
| b
| c = '''''abc''' or '''ABC'''''
| A
| B
| C = ''Memory corruption due to cosmic rays''
| #default = N/A
Šablona:ft end
```

gives abc or ABC

#switch may be used instead of #ifeq:

Šablona:ft gives true
Šablona:ft gives true

### #time:

Šablona:ft is a time and date formatting function (for dates from 1 Jan 1970 only!). The syntax is:

```Šablona:ft
Šablona:ft
```

If the time is not specified, the time at which the article is converted to HTML is used. Note that due to caching, this may be up to a week different to the time at which the article is viewed. Manual updates may be required, this can be achieved by saving the page without making any changes (a "null edit") or viewed with `action=purge` in search string of URL or viewed by a user whose option is "Disable page caching".

The format parameter is a format string similar to the one used by PHP's date.

The following format codes have the same meaning as in PHP. Significant differences from PHP's behaviour, apart from internationalisation (i.e. language and locale differences), should be considered an error of ParserFunctions and should be reported. All numeric format codes return numbers formatted according to the local language, use the xn code described below to override this.

Kód Popis Příklad výstupu Aktuální výstup
Rok:
Y The 4-digit year. e.g. 2006 2020
y The 2-digit year. 00 to 99, e.g. 06 for year 2006. 20
Month:
n The month number, not zero-padded. 1 to 12 10
m The month number, zero-padded. 01 to 12 10
M An abbreviation of the month name. Often internationalised. Jan to Dec 10.
F The full month name. Often internationalised. January říjen
Week:
W ISO 8601 week number (ISO years have full weeks from monday to sunday, and ISO week number 1 always contains January 4 or the first thursday of the civil year), zero-padded. 01 to 52 or 53 (depends on year) 44
Day:
j The day of the month, not zero-padded. 1 to 31 27
d The day of the month, zero-padded. 01 to 31 27
z The day of the year (starting from 0) 0 to 364, or 365 on a leap year 300
D An abbreviation for the day of the week. Rarely internationalised. Mon to Sun út
l The full weekday name. Rarely internationalised. Monday to Sunday úterý
N ISO 8601 day of the week (according to the ISO 8601 week). 1 (for Monday) through 7 (for Sunday) 2
w number of the day of the week (according to the American week). 0 (for Sunday) through 6 (for Saturday) 2
Hour:
a am (between 01:00:00 and 12:59:59 on the same day) or pm, with lowercase (used with the 12-hour format). am or pm pm
A Same as with code a above, but with uppercase. AM or PM PM
g 12-hour format of the hour without leading zeros (one or two digits, used with am/pm or AM/PM). 1 to 12 6
h 12-hour format of the hour, with leading padding zero (two digits, used with am/pm or AM/PM). 01 to 12 06
G 24-hour format of the hour, without leading padding zero (one or two digits). 0 to 23 18
H 24-hour format of the hour, with leading padding zero (two digits). 00 to 23 18
Minutes and seconds:
i The minute, with leading padding zero (two digits). 00 to 59 51
s The second, with leading padding zero (two digits). 00 to 59 50
U Seconds since January 1 1970 00:00:00 GMT. 0 to infinite 1603824710
Miscellaneous:
L Whether it's a leap year. 1 if it is a leap year, 0 otherwise. 1
t Number of days in the month. 28 to 31 31
c ISO 8601 formatted date, same as {{#time:Y-m-dTH:i:s+00:00}}. fixed length string 2020-10-27T18:51:50+00:00
r RFC 2822 formatted date, same as {{#time:D, j M Y H:i:s +0000}} with weekday name and month name not internationalised. variable length string Tue, 27 Oct 2020 18:51:50 +0000

The following format codes are extensions to the PHP syntax:

Code Description
xn Format the next numeric code as a raw ASCII number. For example, in the Hindi language, Šablona:ft produces ०६, 06.
xN Toggle a permanent raw number formatting flag. Like xn, except it lasts until the end of the string or until the same code appears again.
xr Format the next numeric code as a roman numeral. Only works for numbers up to 3000.
xg Output the genitive form of the month name, for languages which make such a distinction between genitive and nominative.
xx A literal "x"
xij The day of the month in Iranian calendar.
xiF The full month name in Iranian calendar
xin The month number in Iranian calendar
xiY The full year in Iranian calendar
xjj The day of the month in Hebrew calendar
xjF The full month name in Hebrew calendar
xjx Genitive form of the month name in Hebrew calendar
xjn The month number in Hebrew calendar
xjY The full year in Hebrew calendar
xkY The full year in Thai solar calendar

Any unrecognised character will be passed through to the output unmodified. There are also two quoting conventions which can be used to output literal characters.

• Characters enclosed in double quotes will be considered literal (with the quotes themselves removed). Unmatched quotes will be considered literal quotes. Example:
• Backslash escaping as in PHP's date() is supported. \H produces a literal H, \" produces a literal ".

More format codes may be added in the future, as demanded by the users of this extension. This may come in the form of either a more complete implementation of PHP's format codes, or additional "x" codes.

The format of the time parameter is identical to the one used by PHP's function strtotime(). It supports both absolute and relative dates, such as "December 11" and/or "+10 hours", which can be used for timezone translation. See also the GNU tar manual for more information.

#### Examples

In combination with user-specified date formatting:

Both give the user-specified format; the two are different if no preference has been specified.

Be careful when piping links:

Use quotes to surround the link code:

#### Range

The range of proper functioning is 01 January 1970 00:00:01 through 19 January 2038 03:14:07, or 1 through $2^{31}-1$ seconds after the start of 1970 (the Year 2038 problem). For arbitrary dates that may exceed this range, use date computing templates such as Šablona:tim instead.

Dates before 1901 give an error message, dates between 1901 and 1970 even give (perhaps depending on the server) a wrong result (!):

#### Incomplete dates

• Šablona:evd (not a year but a time: today, 20:07)
• Šablona:evd (19:97 is not a valid time, therefore interpreted as year, giving the current date and time in that year)
• Šablona:evd (19:67 is not a valid time, therefore interpreted as year; this gives a date that is out of range which is changed to the start of the valid range)
• Šablona:evd (start of the month)
• Šablona:evd (today's day and time, of the given month and year)
• Šablona:evd (today's day, of the given month and year, at 0 hours)
• Šablona:evd (specified date of the current year)

#### February 29

Caution should be taken with February 29, as {{#time:j|February 29}} will vary with the year. For example

#### Timezones

Give UTC for a specified time, expressed in time zone UTC-3:

Give the UTC 3 hours ago:

Give the UTC 3 hours before a specified time expressed as UTC:

Give the UTC 3 hours before a specified time expressed in time zone UTC-3:

Thus "-0300" and "-3" add 3 hours, while "-3 hours" subtracts them.

### #rel2abs:

Šablona:ft converts a relative path to an absolute path.

```Šablona:ft
Šablona:ft
```

A relative path is a path starting with '/', './', '../'. or is containing '/../' or '/.' or is simply the strings '..' or '.'.
If a base path is given, is should be defined in an absolute syntax.

Example:

• If standing in Help:Foo/bar and is calling Šablona:ft, the result will be Help:Foo/baz
• If standing in Help:Foo and is calling Šablona:ft, the result will be baz
• If standing in Help:Foo and is calling Šablona:ft, the result will be Chyba: Neplatná hloubka v cestě: "Help:Foo/../../baz" (pokus o přístup do uzlu vyššího než kořen)
• If calling Šablona:ft, the result will be Help:Bar/baz
• If calling Šablona:ft, the result will be Help:Foo/baz

There is no checks if the path do exist, for that you might use Šablona:ft in combination:

Šablona:ft gives '..' does not exist
Šablona:ft gives '.' exist

### #titleparts:

{{ #titleparts: pagename | n_of_segments | starting_from }}
returns n_of_segments slash-separated segments of pagename, starting from the specified starting segment.

• if starting_from is omitted, it is considered to be equal 1
• namespace part of pagename is converted into localized namespace name

Examples with one numeric parameter:

Examples with two numeric parameters:

This gives two parts of the title, starting at the second part. Likewise:

Examples with negative parameters (which means "counting from the right"):

Introduced in r22711, fixed to allow negative parameters in r28708. See also bug 6067.

### #iferror:

{{#iferror:expression|error|success}} returns error if the expression contains a <strong class="error"> as generated by #expr, #ifexpr, #time, #rel2abs, and some other MediaWiki situations (such as recursive depth and template loop checks). This is most useful in catching bad input passed to such parserfunctions. For example:

• `{{#iferror:{{#expr:1+1}}|bad input|valid expression}}` gives valid expression
• `{{#iferror:{{#expr:1+Z}}|bad input|valid expression}}` gives bad input

The last two parameters are also optional. If the success parameter is omitted, then the expression is returned on success. If the error parameter is also omitted, then no output is generated on error, and expression is returned on success.

• `{{#iferror:{{#expr:1+1}}|bad input}}` gives 2
• `{{#iferror:{{#expr:1+Z}}|bad input}}` gives bad input
• `{{#iferror:{{#expr:1+1}}}}` gives 2
• `{{#iferror:{{#expr:1+Z}}}}` gives

Thus:

• {{#iferror:wikitext|alternative}} means "render wikitext if it is correct, and otherwise alternative".
• {{#iferror:wikitext}} means "render wikitext if it is correct".
Note: this functionality replaces a bug in the older preprocessor allowing #switch to catch expression errors.

## Caveats

### Substitution

Applying "subst:" to a parser function works, provided that there is no space between "subst:" and "#". For details see Help:Substitution. Note that unless a technique like optional substitution is used, substituting a template which uses a parser function does not replace that parser function with its result. This is often undesirable.

### Tables

Currently wiki pipe table syntax doesn't work inside conditionals, but there are some workarounds.

• Hide the pipe from parser functions by putting it in a template, e.g. Šablona:tim.
• Use html style table syntax instead of wiki style table syntax. NB: \$wgUserHtml must be true (this has since been removed, and thus should not need to be set to 'true' - check if it is relevant for your version). This may not work without setting `\$wgUseTidy=true;`.
• See also Help:Table, completely empty rows or columns are not displayed. Empty cells could be also transformed into dummy &nbsp; cells on pages not affected by 5569.

Note that "|" and "=" were always tricky within templates, this is no new issue.

If all else fails, try setting `\$wgUseTidy=true;` in your `LocalSettings.php`.

#### useTidy

If you decide to use this, you will need to download the HTML tidy programme from http://tidy.sourceforge.net/.

### Výrazy

• div is not integer division and is redundant, use / (slash) for real divisions.
• mod používá PHP operátor, který se liší od modulo operátoru v jiných programovacích jazycích, viz Šablona:tim a 6068.
• mod někdy vrací špatný výsledek pro stejnou vstupní hodnotu, viz 6356 a /MOD10000. Aktualizace: hodnoty menší než 1E+12 tím nejsou ovlivněny.
• Platný výsledek výrazu #expr: jako např. 1.0E-7 nelze použít jako vstupní hodnotu pro #expr::
{{#expr:1.0E-7}} yields 1.0E-7 (works now)
• Výsledkem zaokrouhlení round 0 je -0 místo 0. Pro odstranění záporného znaménka zapište výraz x jako 0+(x).

### Prázdné řádky a mezery

Prázné řádky a mezery parser obvykle redukuje. Pokud je tedy potřebujete použít, musíte toto chování obejít pomocí šablony Šablona:tim.

Viz také Nápověda:Prázdné řádky a mezery.

## Code execution

Oddly, the page to which #ifexist is applied (i.e. the page whose existence is the condition) is registered as link target of a link from the page with #ifexist. (See bug #12019.)

## Instalace

Stáhněte všech 5 of these files and put them in a new directory called ParserFunctions in your extensions directory.

If you don't have php5 use these files instead (older revision):

Or, if you have svn, just do:

```svn checkout http://svn.wikimedia.org/svnroot/mediawiki/trunk/extensions/ParserFunctions
```

Then put the following at the end of your LocalSettings.php:

```require_once( "\$IP/extensions/ParserFunctions/ParserFunctions.php" );
```

If you get errors such as "Warning: require_once(/extensions/ParserFunctions/ParserFunctions.php) [function.require-once]: failed to open stream:", you should substitute the line for:

```require_once( 'extensions/ParserFunctions/ParserFunctions.php' );
```

You can also browse the code tree here:

### Troubleshooting

The Current version of ParserFunctions requires php5 to function.

INSTALLATION WARNING: MediaWiki: 1.9.1, PHP: 5.1.2-Debian-0.1~sarge1 (apache2handler) function ctype_alpha not available, had to add the following to Expr.php

```if ( !function_exists('ctype_alpha') ) {
function ctype_alpha(\$string) {
//if ( !preg_match('|[^\pL]|', \$string) )
/* Warning: preg_match() [function.preg-match]: Compilation failed: PCRE does not support
\L, \l, \N, \P, \p, \U, \u, or \X at offset 3 in
/.../extensions/ParserFunctions/Expr.php on line 6
*/
/* alternative: */ //
if ( !preg_match('|[^A-Za-z]|', \$string) )
return true;
else
return false;
}
}
```

If you are using Gentoo Linux's portage system to install php, be sure to have the "ctype" USE flag set for dev-lang/php to avoid the above error.

### Bugs

In version 1.6 and 1.7 if a user has the Cite.php extension already installed, an error is created when running ParserFunctions, "Unknown datatype in hooks for ParserClearState", a simple fix has been found by editing Cite.php. ]

### 1.12.0

If all ParserFunctions evaluate to false, you should check the existence of the global variable:

`\$wgExpensiveParserFunctionLimit = 100;`

It defines the maximum amount of ParserFunctions-calls in one page.

### 1.11.0

I found that the files above didn't work and that I needed the latest from the svn trunk
http://svn.wikimedia.org/svnroot/mediawiki/trunk/extensions/ParserFunctions/

### 1.8 and up

All the ParserFunctions work under 1.8 and up, also in the localised forms.

### 1.7

All the ParserFunctions work under 1.7, but only in English. However, the extension may cause problems when used together with the Cite extension; cf. [2]. For the #time parser functions to work, you must also download SprintfDateCompat.php to the extensions/ParserFunctions directory.

### 1.6

When including the ParserFunctions in 1.6, some notices may be shown. Removing the following line (line 10) in ParserFunctions.php fixes the problem:

`\$wgHooks['LanguageGetMagic'][]       = 'wfParserFunctionsLanguageGetMagic';`

Or alternatively adding the default language to the header function on line 169 may solve the problem:

`function wfParserFunctionsLanguageGetMagic( &\$magicWords, \$langCode='en' ) {`

For the #time parser functions to work, you must also download SprintfDateCompat.php to the extensions/ParserFunctions directory. But actually that won't fix the problem.

If you're not planning to support #time, you may find removing this line helps avoid an error in the ParserClearState call chain:

`\$wgHooks['ParserClearState'][] = array( &\$wgExtParserFunctions, 'clearState' );`

Most ParserFunctions (except #if, which does not work at all) work just as well on MediaWiki 1.6, but the syntax of ParserFunctions is without the '#' character. If you want to use the '#' character, find this section of ParserFunctions.php:

``` \$wgParser->setFunctionHook( 'expr', array( &\$wgExtParserFunctions, 'expr' ) );
\$wgParser->setFunctionHook( 'if', array( &\$wgExtParserFunctions, 'ifHook' ) );
\$wgParser->setFunctionHook( 'ifeq', array( &\$wgExtParserFunctions, 'ifeq' ) );
\$wgParser->setFunctionHook( 'ifexpr', array( &\$wgExtParserFunctions, 'ifexpr' ) );
\$wgParser->setFunctionHook( 'switch', array( &\$wgExtParserFunctions, 'switchHook' ) );
\$wgParser->setFunctionHook( 'ifexist', array( &\$wgExtParserFunctions, 'ifexist' ) );
```

Then, replace it with this:

``` \$wgParser->setFunctionHook( '#expr', array( &\$wgExtParserFunctions, 'expr' ) );
\$wgParser->setFunctionHook( '#if', array( &\$wgExtParserFunctions, 'ifHook' ) );
\$wgParser->setFunctionHook( '#ifeq', array( &\$wgExtParserFunctions, 'ifeq' ) );
\$wgParser->setFunctionHook( '#ifexpr', array( &\$wgExtParserFunctions, 'ifexpr' ) );
\$wgParser->setFunctionHook( '#switch', array( &\$wgExtParserFunctions, 'switchHook' ) );
\$wgParser->setFunctionHook( '#ifexist', array( &\$wgExtParserFunctions, 'ifexist' ) );
```

A simple fix for #if in this version -

Replace:

``` function ifHook( &\$parser, \$test = '', \$then = '', \$else = '' ) {
if (\$test !== '') {
```

on line 57 with:

``` function ifHook( &\$parser, \$test = '', \$then = '', \$else = '' ) {
if ( (string)\$test !== '' ){
```

Although the above fix doesn't appear to work on PHP 4.3.9

If you find some template responses are being unexpectedly wrapped in <pre></pre>

I saw this problem in 1.6.10 using the workarounds here and worked around it by making sure all results from ParserFunction callbacks were trimmed. If a result had a leading space character, then that portion of the template would be wrapped in pre tags. Couldn't figure out what part of the parser was doing this. But force trimming might be a potential workaround based on your needs.

## Alteration and lokalizace

The file ParserFunctions.i18n.php contains the localization for the parserfunctions. Adding more may be done by editing it according to the following guidelines.

In the latest MediaWiki versions, a new case for the language code should be added to function efParserFunctionsWords, for example:

```        \$words['fr'] = array(
'expr'       => array( 0, 'calcul',        'expr' ),
'if'         => array( 0, 'si',            'if' ),
'ifeq'       => array( 0, 'si-similaire',  'ifeq' ),
'ifexpr'     => array( 0, 'si-calcul',     'ifexpr' ),
'switch'     => array( 0, 'achemine',      'switch' ),
'default'    => array( 0, '#default' ); // same
'ifexist'    => array( 0, 'si-existe',     'ifexist' ),
'time'       => array( 0, 'temps',         'time' ),
'rel2abs'    => array( 0, 'rel-a-abso',    'rel2abs' ),
'titleparts' => array( 0, 'part-titre',    'titleparts' ),
);
```
• Please note that every hook established in function wfSetupParserFunctions must have an associated magic-words statement for it to work. Failure to associate a magic word may result in PHP warning messages (see bug #10166).

This method may not work on older version. Alternatively, hooks may be established in function wfSetupParserFunctions, as follows.

```// fr
\$wgParser->setFunctionHook( '#calcul', array( &\$wgExtParserFunctions, 'expr' ) );
\$wgParser->setFunctionHook( '#si', array( &\$wgExtParserFunctions, 'ifHook' ) );
\$wgParser->setFunctionHook( '#si-similaire', array( &\$wgExtParserFunctions, 'ifeq' ) );
\$wgParser->setFunctionHook( '#si-calcul', array( &\$wgExtParserFunctions, 'ifexpr' ) );
\$wgParser->setFunctionHook( '#achemine', array( &\$wgExtParserFunctions, 'switchHook' ) );
\$wgParser->setFunctionHook( '#si-existe', array( &\$wgExtParserFunctions, 'ifexist' ) );
\$wgParser->setFunctionHook( '#temps', array( &\$wgExtParserFunctions, 'time' ) );
```
• Tested on MediaWiki 1.6.10