language/functions.xml
dd87866772c31671146ff778140dc0955c55005c
...
...
@@ -7,12 +7,14 @@
7
7
<title>User-defined functions</title>
8
8

9
9
<para>
10
-
A function may be defined using syntax such as the following:
10
+
A function is defined using the <literal>function</literal> keyword,
11
+
a name, a list of parameters (which might be empty) seperated by commas
12
+
(<literal>,</literal>) enclosed in parentheses, followed by the body of
13
+
the function enclosed in curly braces, such as the following:
11
14
</para>
12
-
<para>
13
-
<example>
14
-
<title>Pseudo code to demonstrate function uses</title>
15
-
<programlisting role="php">
15
+
<example>
16
+
<title>Declaring a new function named <literal>foo</literal></title>
17
+
<programlisting role="php">
16
18
<![CDATA[
17
19
<?php
18
20
function foo($arg_1, $arg_2, /* ..., */ $arg_n)
...
...
@@ -22,12 +24,25 @@ function foo($arg_1, $arg_2, /* ..., */ $arg_n)
22
24
}
23
25
?>
24
26
]]>
25
-
</programlisting>
26
-
</example>
27
-
</para>
27
+
</programlisting>
28
+
</example>
29
+
<note>
30
+
<para>
31
+
As of PHP 8.0.0, the list of parameters may have a trailing comma:
32
+
<informalexample>
33
+
<programlisting role="php">
34
+
<![CDATA[
35
+
<?php
36
+
function foo($arg_1, $arg_2,) { }
37
+
?>
38
+
]]>
39
+
</programlisting>
40
+
</informalexample>
41
+
</para>
42
+
</note>
28
43
29
44
<simpara>
30
-
Any valid PHP code may appear inside a function, even other
45
+
Any valid PHP code may appear inside the body of a function, even other
31
46
functions and <link linkend="language.oop5.basic.class">class</link>
32
47
definitions.
33
48
</simpara>
...
...
@@ -170,15 +185,18 @@ function recursion($a)
170
185
</sect1>
171
186

172
187
<sect1 xml:id="functions.arguments">
173
-
<title>Function arguments</title>
188
+
<title>Function parameters and arguments</title>
174
189

175
190
<simpara>
191
+
The function parameters are declared in the function signature.
176
192
Information may be passed to functions via the argument list,
177
193
which is a comma-delimited list of expressions. The arguments are
178
-
evaluated from left to right, before the function is actually called
194
+
evaluated from left to right and the result is assigned to the parameters of
195
+
the function, before the function is actually called
179
196
(<emphasis>eager</emphasis> evaluation).
180
197
</simpara>
181
198

199
+
<!-- Note: this paragraph feels like it should be moved to the syntax part? -->
182
200
<para>
183
201
PHP supports passing arguments by value (the default), <link
184
202
linkend="functions.arguments.by-reference">passing by
...
...
@@ -188,28 +206,32 @@ function recursion($a)
188
206
argument lists</link> and <link linkend="functions.named-arguments">Named Arguments</link>
189
207
are also supported.
190
208
</para>
191
-
<para>
192
-
<example>
193
-
<title>Passing arrays to functions</title>
194
-
<programlisting role="php">
209
+
<note>
210
+
<para>
211
+
As of PHP 7.3.0, it is possible to have a trailing comma in the argument
212
+
list for a function calls:
213
+
<informalexample>
214
+
<programlisting role="php">
195
215
<![CDATA[
196
216
<?php
197
-
function takes_array($input)
198
-
{
199
-
echo "$input[0] + $input[1] = ", $input[0]+$input[1];
200
-
}
217
+
$v = foo(
218
+
$arg_1,
219
+
$arg_2,
220
+
);
201
221
?>
202
222
]]>
203
-
</programlisting>
204
-
</example>
205
-
</para>
223
+
</programlisting>
224
+
</informalexample>
225
+
</para>
226
+
</note>
227
+

206
228
<para>
207
-
As of PHP 8.0.0, the list of function arguments may include a trailing comma, which
208
-
will be ignored. That is particularly useful in cases where the list of arguments is
209
-
long or contains long variable names, making it convenient to list arguments vertically.
229
+
As of PHP 8.0.0, the list of function parameters may include a trailing comma, which
230
+
will be ignored. That is particularly useful in cases where the list of parameters is
231
+
long or contains long variable names, making it convenient to list parameters vertically.
210
232
</para>
211
233
<example>
212
-
<title>Function Argument List with trailing Comma</title>
234
+
<title>Function parameter list with trailing comma</title>
213
235
<programlisting role="php">
214
236
<![CDATA[
215
237
<?php
...
...
@@ -224,28 +246,6 @@ function takes_many_args(
224
246
// ...
225
247
}
226
248
?>
227
-
]]>
228
-
</programlisting>
229
-
</example>
230
-
<para>
231
-
As of PHP 8.0.0, declaring mandatory arguments after optional arguments
232
-
is deprecated. This can generally be resolved by dropping the default value.
233
-
One exception to this rule are arguments of the form
234
-
<code>Type $param = null</code>, where the &null; default makes the type implicitly
235
-
nullable. This usage remains allowed, though it is recommended to use an
236
-
explicit nullable type instead.
237
-
</para>
238
-
<example>
239
-
<title>Declaring optional arguments after mandatory arguments</title>
240
-
<programlisting role="php">
241
-
<![CDATA[
242
-
<?php
243
-
function foo($a = [], $b) {} // Before
244
-
function foo($a, $b) {} // After
245
-

246
-
function bar(A $a = null, $b) {} // Still allowed
247
-
function bar(?A $a, $b) {} // Recommended
248
-
?>
249
249
]]>
250
250
</programlisting>
251
251
</example>
...
...
@@ -261,11 +261,11 @@ function bar(?A $a, $b) {} // Recommended
261
261
</simpara>
262
262
<para>
263
263
To have an argument to a function always passed by reference, prepend an
264
-
ampersand (&amp;) to the argument name in the function definition:
264
+
ampersand (&amp;) to the parameter name in the function definition:
265
265
</para>
266
266
<para>
267
267
<example>
268
-
<title>Passing function parameters by reference</title>
268
+
<title>Passing function arguments by reference</title>
269
269
<programlisting role="php">
270
270
<![CDATA[
271
271
<?php
...
...
@@ -282,15 +282,18 @@ echo $str; // outputs 'This is a string, and something extra.'
282
282
</example>
283
283
</para>
284
284
<para>
285
-
It is an error to pass a value as argument which is supposed to be passed by reference.
285
+
It is an error to pass a constant expression as an argument to a parameter
286
+
that expects to be passed by reference.
286
287
</para>
287
288
</sect2>
288
289
<sect2 xml:id="functions.arguments.default">
289
-
<title>Default argument values</title>
290
+
<title>Default parameter values</title>
290
291

291
292
<para>
292
-
A function may define C++-style default values for scalar
293
-
arguments as follows:
293
+
A function may define default values for parameters using syntax similar
294
+
to assigning a variable. The default is used only when the parameter's argument is
295
+
not passed. Note that passing &null; does <emphasis>not</emphasis>
296
+
assign the default value.
294
297
</para>
295
298
<para>
296
299
<example>
...
...
@@ -319,8 +322,9 @@ Making a cup of espresso.
319
322
</example>
320
323
</para>
321
324
<para>
322
-
PHP also allows the use of <type>array</type>s and the special type &null;
323
-
as default values, for example:
325
+
Default parameter values may be scalar values, <type>array</type>s,
326
+
the special type &null;, and as of PHP 8.1.0, objects using the
327
+
<link linkend="language.oop5.basic.new">new ClassName()</link> syntax.
324
328
</para>
325
329
<para>
326
330
<example>
...
...
@@ -334,43 +338,82 @@ function makecoffee($types = array("cappuccino"), $coffeeMaker = NULL)
334
338
return "Making a cup of ".join(", ", $types)." with $device.\n";
335
339
}
336
340
echo makecoffee();
337
-
echo makecoffee(array("cappuccino", "lavazza"), "teapot");
338
-
?>
341
+
echo makecoffee(array("cappuccino", "lavazza"), "teapot");?>
339
342
]]>
340
343
</programlisting>
344
+
&example.outputs;
345
+
<screen>
346
+
<![CDATA[
347
+
Making a cup of cappuccino with hands.
348
+
Making a cup of cappuccino, lavazza with teapot.
349
+
]]>
350
+
</screen>
341
351
</example>
352
+
</para>
353
+
<para>
354
+
<example>
355
+
<title>Using objects as default values (as of PHP 8.1.0)</title>
356
+
<programlisting role="php">
357
+
<![CDATA[
358
+
<?php
359
+
class DefaultCoffeeMaker {
360
+
public function brew() {
361
+
return "Making coffee.\n";
362
+
}
363
+
}
364
+
class FancyCoffeeMaker {
365
+
public function brew() {
366
+
return "Crafting a beautiful coffee just for you.\n";
367
+
}
368
+
}
369
+
function makecoffee($coffeeMaker = new DefaultCoffeeMaker)
370
+
{
371
+
return $coffeeMaker->brew();
372
+
}
373
+
echo makecoffee();
374
+
echo makecoffee(new FancyCoffeeMaker);
375
+
?>
376
+
]]>
377
+
</programlisting>
342
378

379
+
&example.outputs;
380
+
<screen>
381
+
<![CDATA[
382
+
Making coffee.
383
+
Crafting a beautiful coffee just for you.
384
+
]]>
385
+
</screen>
386
+
</example>
343
387
</para>
344
388
<simpara>
345
389
The default value must be a constant expression, not (for
346
390
example) a variable, a class member or a function call.
347
391
</simpara>
348
392
<para>
349
-
Note that when using default arguments, any defaults should be on
350
-
the right side of any non-default arguments; otherwise, things
351
-
will not work as expected. Consider the following code snippet:
393
+
Note that any optional parameters should be specified after any
394
+
required parameters, otherwise they cannot be omitted from calls.
395
+
Consider the following example:
352
396
</para>
353
397
<para>
354
398
<example>
355
-
<title>Incorrect usage of default function arguments</title>
399
+
<title>Incorrect usage of default function parameters</title>
356
400
<programlisting role="php">
357
401
<![CDATA[
358
402
<?php
359
-
function makeyogurt($type = "acidophilus", $flavour)
403
+
function makeyogurt($container = "bowl", $flavour)
360
404
{
361
-
return "Making a bowl of $type $flavour.\n";
405
+
return "Making a $container of $flavour yogurt.\n";
362
406
}
363
407

364
-
echo makeyogurt("raspberry"); // won't work as expected
408
+
echo makeyogurt("raspberry"); // "raspberry" is $container, not $flavour
365
409
?>
366
410
]]>
367
411
</programlisting>
368
412
&example.outputs;
369
413
<screen>
370
414
<![CDATA[
371
-
Warning: Missing argument 2 in call to makeyogurt() in
372
-
/usr/local/etc/httpd/htdocs/phptest/functest.html on line 41
373
-
Making a bowl of raspberry .
415
+
Fatal error: Uncaught ArgumentCountError: Too few arguments
416
+
to function makeyogurt(), 1 passed in example.php on line 42
374
417
]]>
375
418
</screen>
376
419
</example>
...
...
@@ -380,30 +423,93 @@ Making a bowl of raspberry .
380
423
</para>
381
424
<para>
382
425
<example>
383
-
<title>Correct usage of default function arguments</title>
426
+
<title>Correct usage of default function parameters</title>
384
427
<programlisting role="php">
385
428
<![CDATA[
386
429
<?php
387
-
function makeyogurt($flavour, $type = "acidophilus")
430
+
function makeyogurt($flavour, $container = "bowl")
388
431
{
389
-
return "Making a bowl of $type $flavour.\n";
432
+
return "Making a $container of $flavour yogurt.\n";
390
433
}
391
434

392
-
echo makeyogurt("raspberry"); // works as expected
435
+
echo makeyogurt("raspberry"); // "raspberry" is $flavour
393
436
?>
394
437
]]>
395
438
</programlisting>
396
439
&example.outputs;
397
440
<screen>
398
441
<![CDATA[
399
-
Making a bowl of acidophilus raspberry.
442
+
Making a bowl of raspberry yogurt.
400
443
]]>
401
444
</screen>
402
445
</example>
403
446
</para>
447
+
<para>
448
+
As of PHP 8.0.0, <link linkend="functions.named-arguments">named arguments</link>
449
+
can be used to skip over multiple optional parameters.
450
+
</para>
451
+
<para>
452
+
<example>
453
+
<title>Correct usage of default function parameters</title>
454
+
<programlisting role="php">
455
+
<![CDATA[
456
+
<?php
457
+
function makeyogurt($container = "bowl", $flavour = "raspberry", $style = "Greek")
458
+
{
459
+
return "Making a $container of $flavour $style yogurt.\n";
460
+
}
461
+

462
+
echo makeyogurt(style: "natural");
463
+
?>
464
+
]]>
465
+
</programlisting>
466
+
&example.outputs;
467
+
<screen>
468
+
<![CDATA[
469
+
Making a bowl of raspberry natural yogurt.
470
+
]]>
471
+
</screen>
472
+
</example>
473
+
</para>
474
+
<para>
475
+
As of PHP 8.0.0, declaring mandatory parameters after optional parameters
476
+
is <emphasis>deprecated</emphasis>. This can generally be resolved by
477
+
dropping the default value, since it will never be used.
478
+
One exception to this rule are parameters of the form
479
+
<code>Type $param = null</code>, where the &null; default makes the type implicitly
480
+
nullable. This usage is deprecated as of PHP 8.4.0, and an explicit
481
+
<link linkend="language.types.declarations.nullable">nullable type</link>
482
+
should be used instead.
483
+
<example>
484
+
<title>Declaring optional parameters after mandatory parameters</title>
485
+
<programlisting role="php">
486
+
<![CDATA[
487
+
<?php
488
+

489
+
function foo($a = [], $b) {} // Default not used; deprecated as of PHP 8.0.0
490
+
function foo($a, $b) {} // Functionally equivalent, no deprecation notice
491
+

492
+
function bar(A $a = null, $b) {} // As of PHP 8.1.0, $a is implicitly required
493
+
// (because it comes before the required one),
494
+
// but implicitly nullable (deprecated as of PHP 8.4.0),
495
+
// because the default parameter value is null
496
+
function bar(?A $a, $b) {} // Recommended
497
+

498
+
?>
499
+
]]>
500
+
</programlisting>
501
+
</example>
502
+
</para>
404
503
<note>
405
504
<simpara>
406
-
Arguments that are passed by reference may have a default value.
505
+
As of PHP 7.1.0, omitting a parameter which does not specify a default
506
+
throws an <classname>ArgumentCountError</classname>; in previous versions
507
+
it raised a Warning.
508
+
</simpara>
509
+
</note>
510
+
<note>
511
+
<simpara>
512
+
Parameters that expect the argument by reference may have a default value.
407
513
</simpara>
408
514
</note>
409
515
</sect2>
...
...
@@ -417,22 +523,11 @@ Making a bowl of acidophilus raspberry.
417
523
<literal>...</literal> token.
418
524
</simpara>
419
525

420
-
<note>
421
-
<simpara>
422
-
It is also possible to achieve variable-length arguments by using
423
-
<function>func_num_args</function>,
424
-
<function>func_get_arg</function>, and
425
-
<function>func_get_args</function> functions.
426
-
This technique is not recommended as it was used prior to the introduction
427
-
of the <literal>...</literal> token.
428
-
</simpara>
429
-
</note>
430
-

431
526
<para>
432
-
Argument lists may include the
527
+
Parameter lists may include the
433
528
<literal>...</literal> token to denote that the function accepts a
434
529
variable number of arguments. The arguments will be passed into the
435
-
given variable as an array; for example:
530
+
given variable as an &array;:
436
531

437
532
<example>
438
533
<title>Using <literal>...</literal> to access variable arguments</title>
...
...
@@ -492,7 +587,7 @@ echo add(...$a);
492
587
</para>
493
588

494
589
<para>
495
-
You may specify normal positional arguments before the
590
+
You may specify normal positional parameters before the
496
591
<literal>...</literal> token. In this case, only the trailing arguments
497
592
that don't match a positional argument will be added to the array
498
593
generated by <literal>...</literal>.
...
...
@@ -543,46 +638,6 @@ Catchable fatal error: Argument 2 passed to total_intervals() must be an instanc
543
638
(<literal>&amp;</literal>).
544
639
</para>
545
640

546
-
<sect3 xml:id="functions.variable-arg-list.old">
547
-
<title>Older versions of PHP</title>
548
-

549
-
<para>
550
-
No special syntax is required to note that a function is variadic;
551
-
however access to the function's arguments must use
552
-
<function>func_num_args</function>, <function>func_get_arg</function>
553
-
and <function>func_get_args</function>.
554
-
</para>
555
-

556
-
<para>
557
-
The first example above would be implemented as follows in old versions of PHP:
558
-

559
-
<example>
560
-
<title>Accessing variable arguments in old PHP versions</title>
561
-
<programlisting role="php">
562
-
<![CDATA[
563
-
<?php
564
-
function sum() {
565
-
$acc = 0;
566
-
foreach (func_get_args() as $n) {
567
-
$acc += $n;
568
-
}
569
-
return $acc;
570
-
}
571
-

572
-
echo sum(1, 2, 3, 4);
573
-
?>
574
-
]]>
575
-
</programlisting>
576
-
&example.outputs;
577
-
<screen>
578
-
<![CDATA[
579
-
10
580
-
]]>
581
-
</screen>
582
-
</example>
583
-
</para>
584
-
</sect3>
585
-

586
641
</sect2>
587
642

588
643
<sect2 xml:id="functions.named-arguments">
...
...
@@ -606,7 +661,7 @@ echo sum(1, 2, 3, 4);
606
661
<example>
607
662
<title>Named argument syntax</title>
608
663
<programlisting role="php">
609
-
<![CDATA[
664
+
<![CDATA[
610
665
<?php
611
666
myFunction(paramName: $value);
612
667
array_foobar(array: $value);
...
...
@@ -621,7 +676,7 @@ function_name($variableStoringParamName: $value);
621
676
<example>
622
677
<title>Positional arguments versus named arguments</title>
623
678
<programlisting role="php">
624
-
<![CDATA[
679
+
<![CDATA[
625
680
<?php
626
681
// Using positional arguments:
627
682
array_fill(0, 100, 50);
...
...
@@ -640,7 +695,7 @@ array_fill(start_index: 0, count: 100, value: 50);
640
695
<example>
641
696
<title>Same example as above with a different order of parameters</title>
642
697
<programlisting role="php">
643
-
<![CDATA[
698
+
<![CDATA[
644
699
<?php
645
700
array_fill(value: 50, count: 100, start_index: 0);
646
701
?>
...
...
@@ -658,7 +713,7 @@ array_fill(value: 50, count: 100, start_index: 0);
658
713
<example>
659
714
<title>Combining named arguments with positional arguments</title>
660
715
<programlisting role="php">
661
-
<![CDATA[
716
+
<![CDATA[
662
717
<?php
663
718
htmlspecialchars($string, double_encode: false);
664
719
// Same as
...
...
@@ -669,20 +724,47 @@ htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, 'UTF-8', fa
669
724
</example>
670
725

671
726
<para>
672
-
Passing the same parameter multiple times results in an Error exception.
727
+
Passing an argument to the same named parameter multiple times results in an
728
+
<classname>Error</classname> exception.
673
729
</para>
674
730

675
731
<example>
676
-
<title>Error exception when passing the same parameter multiple times</title>
732
+
<title>Error thrown when passing an argument to the same named parameter multiple times</title>
677
733
<programlisting role="php">
678
-
<![CDATA[
734
+
<![CDATA[
679
735
<?php
736
+

680
737
function foo($param) { ... }
681
738

682
739
foo(param: 1, param: 2);
683
740
// Error: Named parameter $param overwrites previous argument
741
+

684
742
foo(1, param: 2);
685
743
// Error: Named parameter $param overwrites previous argument
744
+

745
+
?>
746
+
]]>
747
+
</programlisting>
748
+
</example>
749
+

750
+
<para>
751
+
As of PHP 8.1.0, it is possible to use named arguments after unpacking the arguments.
752
+
A named argument <emphasis>must not</emphasis> override an already unpacked argument.
753
+
</para>
754
+

755
+
<example>
756
+
<title>Use named arguments after unpacking</title>
757
+
<programlisting role="php">
758
+
<![CDATA[
759
+
<?php
760
+
function foo($a, $b, $c = 3, $d = 4) {
761
+
return $a + $b + $c + $d;
762
+
}
763
+

764
+
var_dump(foo(...[1, 2], d: 40)); // 46
765
+
var_dump(foo(...['b' => 2, 'a' => 1], d: 40)); // 46
766
+

767
+
var_dump(foo(...[1, 2], b: 20)); // Fatal error. Named parameter $b overwrites previous argument
686
768
?>
687
769
]]>
688
770
</programlisting>
...
...
@@ -979,6 +1061,38 @@ $func(); // prints "bar"
979
1061
be thrown in this case.
980
1062
</simpara>
981
1063
</note>
1064
+
<note>
1065
+
<para>
1066
+
Scalar types for built-in functions are nullable by default in coercive mode.
1067
+
As of PHP 8.1.0, passing &null; to an internal function parameter that is not declared nullable
1068
+
is discouraged and emits a deprecation notice in coercive mode to align with the behavior of user-defined functions,
1069
+
where scalar types need to be marked as nullable explicitly.
1070
+
</para>
1071
+

1072
+
<para>
1073
+
For example, <function>strlen</function> function expects the parameter <literal>$string</literal>
1074
+
to be a non-nullable &string;.
1075
+
For historical reasons, PHP allows passing &null; for this parameter in coercive mode, and the parameter is
1076
+
implicitly cast to <type>string</type>, resulting in a <literal>""</literal> value.
1077
+
In contrast, a <classname>TypeError</classname> is emitted in strict mode.
1078
+
</para>
1079
+

1080
+
<informalexample>
1081
+
<programlisting role="php">
1082
+
<![CDATA[
1083
+
<?php
1084
+
var_dump(strlen(null));
1085
+
// "Deprecated: Passing null to parameter #1 ($string) of type string is deprecated" as of PHP 8.1.0
1086
+
// int(0)
1087
+

1088
+
var_dump(str_contains("foobar", null));
1089
+
// "Deprecated: Passing null to parameter #2 ($needle) of type string is deprecated" as of PHP 8.1.0
1090
+
// bool(true)
1091
+
?>
1092
+
]]>
1093
+
</programlisting>
1094
+
</informalexample>
1095
+
</note>
982
1096

983
1097
<sect2 role="seealso">
984
1098
&reftitle.seealso;
...
...
@@ -1034,8 +1148,7 @@ echo preg_replace_callback('~-([a-z])~', function ($match) {
1034
1148
<programlisting role="php">
1035
1149
<![CDATA[
1036
1150
<?php
1037
-
$greet = function($name)
1038
-
{
1151
+
$greet = function($name) {
1039
1152
printf("Hello %s\r\n", $name);
1040
1153
};
1041
1154

...
...
@@ -1285,7 +1398,7 @@ NULL
1285
1398
$func = static function() {
1286
1399
// function body
1287
1400
};
1288
-
$func = $func->bindTo(new StdClass);
1401
+
$func = $func->bindTo(new stdClass);
1289
1402
$func();
1290
1403

1291
1404
?>
...
...
@@ -1313,6 +1426,13 @@ Warning: Cannot bind an instance to a static closure in %s on line %d
1313
1426
</row>
1314
1427
</thead>
1315
1428
<tbody>
1429
+
<row>
1430
+
<entry>8.3.0</entry>
1431
+
<entry>
1432
+
Closures created from <link linkend="language.oop5.magic">magic
1433
+
methods</link> can accept named parameters.
1434
+
</entry>
1435
+
</row>
1316
1436
<row>
1317
1437
<entry>7.1.0</entry>
1318
1438
<entry>
...
...
@@ -1430,7 +1550,7 @@ var_export($fn(5)(10));
1430
1550
<?php
1431
1551

1432
1552
fn(array $x) => $x;
1433
-
static fn(): int => $x;
1553
+
static fn($x): int => $x;
1434
1554
fn($x = 42) => $x;
1435
1555
fn(&$x) => $x;
1436
1556
fn&($x) => $x;
...
...
@@ -1611,7 +1731,7 @@ $privateMethod(); // Foo1::privateMethod
1611
1731
<note>
1612
1732
<para>
1613
1733
The first-class callable syntax cannot be combined with the <link linkend="language.oop5.basic.nullsafe">nullsafe operator</link>. Both of the following result in a compile-time error:
1614
-
<example>
1734
+
<informalexample>
1615
1735
<programlisting role="php">
1616
1736
<![CDATA[
1617
1737
<?php
...
...
@@ -1620,7 +1740,7 @@ $obj?->prop->method(...);
1620
1740
?>
1621
1741
]]>
1622
1742
</programlisting>
1623
-
</example>
1743
+
</informalexample>
1624
1744
</para>
1625
1745
</note>
1626
1746
</sect1>
1627
1747



Translation status