mirror of
https://github.com/sigmasternchen/php-doc-en
synced 2025-03-17 01:18:55 +00:00
7839d91186
removing the others git-svn-id: https://svn.php.net/repository/phpdoc/en/trunk@78562 c90b9560-bf6c-de11-be94-00142212c4b1
739 lines
20 KiB
XML
739 lines
20 KiB
XML
<!-- D O N O T E D I T T H I S F I L E ! ! !
|
|
|
|
it is still here for historical reasons only
|
|
(as translators may need to check old revision diffs)
|
|
|
|
if you want to change things documented in this file
|
|
you should now edit the files found under en/reference
|
|
instead -->
|
|
|
|
<?xml version="1.0" encoding="iso-8859-1"?>
|
|
<!-- $Revision: 1.39 $ -->
|
|
<reference id="ref.classobj">
|
|
<title>Class/Object Functions</title>
|
|
<titleabbrev>Classes/Objects</titleabbrev>
|
|
|
|
<partintro>
|
|
<sect1 id="classobj.partintro">
|
|
<title>Introduction</title>
|
|
<sect2 id="classobj.intro">
|
|
<title>About</title>
|
|
<para>
|
|
These functions allow you to obtain information about classes
|
|
and instance objects. You can obtain the name of the class to
|
|
which a object belongs, as well as its member properties and
|
|
methods. Using these functions, you can find out not only the
|
|
class membership of an object, but also its parentage (i.e.
|
|
what class is the object class extending).
|
|
</para>
|
|
</sect2>
|
|
<sect2 id="classobj.example">
|
|
<title>An example of use</title>
|
|
<para>
|
|
In this example, we first define a base class and an extension
|
|
of the class. The base class describes a general vegetable,
|
|
whether it is edible or not and what is its color. The subclass
|
|
<varname>Spinach</varname> adds a method to cook it and another to
|
|
find out if it is cooked.
|
|
</para>
|
|
<para>
|
|
<example>
|
|
<title>classes.inc</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
// base class with member properties and methods
|
|
class Vegetable {
|
|
|
|
var $edible;
|
|
var $color;
|
|
|
|
function Vegetable( $edible, $color="green" ) {
|
|
$this->edible = $edible;
|
|
$this->color = $color;
|
|
}
|
|
|
|
function is_edible() {
|
|
return $this->edible;
|
|
}
|
|
|
|
function what_color() {
|
|
return $this->color;
|
|
}
|
|
|
|
} // end of class Vegetable
|
|
|
|
|
|
// extends the base class
|
|
class Spinach extends Vegetable {
|
|
|
|
var $cooked = false;
|
|
|
|
function Spinach() {
|
|
$this->Vegetable( true, "green" );
|
|
}
|
|
|
|
function cook_it() {
|
|
$this->cooked = true;
|
|
}
|
|
|
|
function is_cooked() {
|
|
return $this->cooked;
|
|
}
|
|
|
|
} // end of class Spinach
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
We then instantiate 2 objects from these classes and print out
|
|
information about them, including their class parentage.
|
|
We also define some utility functions, mainly to have a nice printout
|
|
of the variables.
|
|
</para>
|
|
<para>
|
|
<example>
|
|
<title>test_script.php</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<pre>
|
|
<?php
|
|
|
|
include "classes.inc";
|
|
|
|
// utility functions
|
|
|
|
function print_vars($obj) {
|
|
$arr = get_object_vars($obj);
|
|
while (list($prop, $val) = each($arr))
|
|
echo "\t$prop = $val\n";
|
|
}
|
|
|
|
function print_methods($obj) {
|
|
$arr = get_class_methods(get_class($obj));
|
|
foreach ($arr as $method)
|
|
echo "\tfunction $method()\n";
|
|
}
|
|
|
|
function class_parentage($obj, $class) {
|
|
global $$obj;
|
|
if (is_subclass_of($$obj, $class)) {
|
|
echo "Object $obj belongs to class ".get_class($$obj);
|
|
echo " a subclass of $class\n";
|
|
} else {
|
|
echo "Object $obj does not belong to a subclass of $class\n";
|
|
}
|
|
}
|
|
|
|
// instantiate 2 objects
|
|
|
|
$veggie = new Vegetable(true,"blue");
|
|
$leafy = new Spinach();
|
|
|
|
// print out information about objects
|
|
echo "veggie: CLASS ".get_class($veggie)."\n";
|
|
echo "leafy: CLASS ".get_class($leafy);
|
|
echo ", PARENT ".get_parent_class($leafy)."\n";
|
|
|
|
// show veggie properties
|
|
echo "\nveggie: Properties\n";
|
|
print_vars($veggie);
|
|
|
|
// and leafy methods
|
|
echo "\nleafy: Methods\n";
|
|
print_methods($leafy);
|
|
|
|
echo "\nParentage:\n";
|
|
class_parentage("leafy", "Spinach");
|
|
class_parentage("leafy", "Vegetable");
|
|
?>
|
|
</pre>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
One important thing to note in the example above is that
|
|
the object <varname>$leafy</varname> is an instance of the class
|
|
<classname>Spinach</classname> which is a subclass of
|
|
<classname>Vegetable</classname>,
|
|
therefore the last part of the script above will output:
|
|
</para>
|
|
<para>
|
|
<informalexample>
|
|
<programlisting>
|
|
<![CDATA[
|
|
[...]
|
|
Parentage:
|
|
Object leafy does not belong to a subclass of Spinach
|
|
Object leafy belongs to class spinach a subclass of Vegetable
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
</sect2>
|
|
</sect1>
|
|
</partintro>
|
|
|
|
<refentry id="function.call-user-method">
|
|
<refnamediv>
|
|
<refname>call_user_method</refname>
|
|
<refpurpose>
|
|
Call a user method on an specific object [deprecated]
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>mixed</type><methodname>call_user_method</methodname>
|
|
<methodparam><type>string</type><parameter>method_name</parameter></methodparam>
|
|
<methodparam><type>object</type><parameter>obj</parameter></methodparam>
|
|
<methodparam choice="opt"><type>mixed</type><parameter>parameter</parameter></methodparam>
|
|
<methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<warning>
|
|
<para>
|
|
The <function>call_user_method</function> function is deprecated
|
|
as of PHP 4.1.0, use the <function>call_user_func</function> variety
|
|
with the <literal>array(&$obj, "method_name")</literal> syntax instead.
|
|
</para>
|
|
</warning>
|
|
<para>
|
|
Calls the method referred by <parameter>method_name</parameter> from
|
|
the user defined <parameter>obj</parameter> object. An example of usage
|
|
is below, where we define a class, instantiate an object and use
|
|
<function>call_user_method</function> to call indirectly its
|
|
<varname>print_info</varname> method.
|
|
<informalexample>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
class Country {
|
|
var $NAME;
|
|
var $TLD;
|
|
|
|
function Country($name, $tld) {
|
|
$this->NAME = $name;
|
|
$this->TLD = $tld;
|
|
}
|
|
|
|
function print_info($prestr="") {
|
|
echo $prestr."Country: ".$this->NAME."\n";
|
|
echo $prestr."Top Level Domain: ".$this->TLD."\n";
|
|
}
|
|
}
|
|
|
|
$cntry = new Country("Peru","pe");
|
|
|
|
echo "* Calling the object method directly\n";
|
|
$cntry->print_info();
|
|
|
|
echo "\n* Calling the same method indirectly\n";
|
|
call_user_method ("print_info", $cntry, "\t");
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
<simpara>
|
|
See also <function>call_user_func_array</function>,
|
|
<function>call_user_func</function>, and
|
|
<function>call_user_method_array</function>.
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.call-user-method-array">
|
|
<refnamediv>
|
|
<refname>call_user_method_array</refname>
|
|
<refpurpose>
|
|
Call a user method given with an array of parameters [deprecated]
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>mixed</type><methodname>call_user_method_array</methodname>
|
|
<methodparam><type>string</type><parameter>method_name</parameter></methodparam>
|
|
<methodparam><type>object</type><parameter>obj</parameter></methodparam>
|
|
<methodparam choice="opt"><type>array</type><parameter>paramarr</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<warning>
|
|
<para>
|
|
The <function>call_user_method_array</function> function is deprecated
|
|
as of PHP 4.1.0, use the <function>call_user_func_array</function> variety
|
|
with the <literal>array(&$obj, "method_name")</literal> syntax instead.
|
|
</para>
|
|
</warning>
|
|
<para>
|
|
Calls the method referred by <parameter>method_name</parameter> from
|
|
the user defined <parameter>obj</parameter> object, using the parameters
|
|
in <parameter>paramarr</parameter>.
|
|
</para>
|
|
<para>
|
|
See also:
|
|
<function>call_user_func_array</function>,
|
|
<function>call_user_func</function>,
|
|
<function>call_user_method</function>.
|
|
</para>
|
|
<note>
|
|
<para>
|
|
This function was added to the CVS code after release of PHP 4.0.4pl1
|
|
</para>
|
|
</note>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.class-exists">
|
|
<refnamediv>
|
|
<refname>class_exists</refname>
|
|
<refpurpose>Checks if the class has been defined</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>bool</type><methodname>class_exists</methodname>
|
|
<methodparam><type>string</type><parameter>class_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns &true; if the class given by
|
|
<parameter>class_name</parameter> has been defined,
|
|
&false; otherwise.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-class">
|
|
<refnamediv>
|
|
<refname>get_class</refname>
|
|
<refpurpose>Returns the name of the class of an object</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>string</type><methodname>get_class</methodname>
|
|
<methodparam><type>object</type><parameter>obj</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns the name of the class of which the
|
|
object <parameter>obj</parameter> is an instance. Returns
|
|
&false; if <parameter>obj</parameter> is not an object.
|
|
</para>
|
|
<note>
|
|
<simpara>
|
|
<function>get_class</function> returns a user defined class name
|
|
in lowercase. A class defined in a PHP extension is returned
|
|
in its original notation.
|
|
</simpara>
|
|
</note>
|
|
<simpara>
|
|
See also <function>get_parent_class</function>,
|
|
<function>gettype</function>, and
|
|
<function>is_subclass_of</function>.
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-class-methods">
|
|
<refnamediv>
|
|
<refname>get_class_methods</refname>
|
|
<refpurpose>Returns an array of class methods' names</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>array</type><methodname>get_class_methods</methodname>
|
|
<methodparam><type>mixed</type><parameter>class_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns an array of method names defined for the
|
|
class specified by <parameter>class_name</parameter>.
|
|
</para>
|
|
<note>
|
|
<para>
|
|
As of PHP 4.0.6, you can specify the object itself instead of
|
|
<parameter>class_name</parameter>. For example:
|
|
<informalexample>
|
|
<programlisting>
|
|
<![CDATA[
|
|
$class_methods = get_class_methods($my_class); // see below the full example
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
</note>
|
|
<para>
|
|
<example>
|
|
<title><function>get_class_methods</function> example</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
class myclass {
|
|
// constructor
|
|
function myclass() {
|
|
return(true);
|
|
}
|
|
|
|
// method 1
|
|
function myfunc1() {
|
|
return(true);
|
|
}
|
|
|
|
// method 2
|
|
function myfunc2() {
|
|
return(true);
|
|
}
|
|
}
|
|
|
|
$my_object = new myclass();
|
|
|
|
$class_methods = get_class_methods(get_class($my_object));
|
|
|
|
foreach ($class_methods as $method_name) {
|
|
echo "$method_name\n";
|
|
}
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
Will produce:
|
|
<informalexample>
|
|
<programlisting>
|
|
<![CDATA[
|
|
myclass
|
|
myfunc1
|
|
myfunc2
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class_vars</function> and
|
|
<function>get_object_vars</function>.
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-class-vars">
|
|
<refnamediv>
|
|
<refname>get_class_vars</refname>
|
|
<refpurpose>
|
|
Returns an array of default properties of the class
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>array</type><methodname>get_class_vars</methodname>
|
|
<methodparam><type>string</type><parameter>class_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function will return an associative array of default
|
|
properties of the class. The resulting array elements are in the
|
|
form of <parameter>varname => value</parameter>.
|
|
</para>
|
|
<note>
|
|
<para>
|
|
Uninitialized class variables will not be reported by
|
|
<function>get_class_vars</function>.
|
|
</para>
|
|
</note>
|
|
<para>
|
|
<example>
|
|
<title><function>get_class_vars</function> example</title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
|
|
class myclass {
|
|
|
|
var $var1; // this has no default value...
|
|
var $var2 = "xyz";
|
|
var $var3 = 100;
|
|
|
|
// constructor
|
|
function myclass() {
|
|
return(true);
|
|
}
|
|
|
|
}
|
|
|
|
$my_class = new myclass();
|
|
|
|
$class_vars = get_class_vars(get_class($my_class));
|
|
|
|
foreach ($class_vars as $name => $value) {
|
|
echo "$name : $value\n";
|
|
}
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
</para>
|
|
<para>
|
|
Will produce:
|
|
<informalexample>
|
|
<programlisting>
|
|
<![CDATA[
|
|
var2 : xyz
|
|
var3 : 100
|
|
]]>
|
|
</programlisting>
|
|
</informalexample>
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class_methods</function>,
|
|
<function>get_object_vars</function>
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-declared-classes">
|
|
<refnamediv>
|
|
<refname>get_declared_classes</refname>
|
|
<refpurpose>Returns an array with the name of the defined classes</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>array</type><methodname>get_declared_classes</methodname>
|
|
<void/>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns an array of the names of the declared classes
|
|
in the current script.
|
|
</para>
|
|
<note>
|
|
<para>
|
|
In PHP 4.0.1pl2, three extra classes are returned at the beginning of
|
|
the array: <classname>stdClass</classname> (defined in
|
|
<filename>Zend/zend.c</filename>),
|
|
<classname>OverloadedTestClass</classname> (defined in
|
|
<filename>ext/standard/basic_functions.c</filename>)
|
|
and <classname>Directory</classname>
|
|
(defined in <filename>ext/standard/dir.c</filename>).
|
|
</para>
|
|
<para>
|
|
Also note that depending on what libraries you have compiled
|
|
into PHP, additional classes could be present. This means that
|
|
you will not be able to define your own classes using these
|
|
names. There is a list of predefined classes in the <link
|
|
linkend="reserved.classes">Predefined Classes</link> section of
|
|
the appendices.
|
|
</para>
|
|
</note>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-object-vars">
|
|
<refnamediv>
|
|
<refname>get_object_vars</refname>
|
|
<refpurpose>Returns an associative array of object properties</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>array</type><methodname>get_object_vars</methodname>
|
|
<methodparam><type>object</type><parameter>obj</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns an associative array of defined object properties
|
|
for the specified object <parameter>obj</parameter>. If variables
|
|
declared in the class of which the <parameter>obj</parameter> is an
|
|
instance, have not been assigned a value, those will not be returned
|
|
in the array.
|
|
<example>
|
|
<title>Use of <function>get_object_vars</function></title>
|
|
<programlisting role="php">
|
|
<![CDATA[
|
|
<?php
|
|
class Point2D {
|
|
var $x, $y;
|
|
var $label;
|
|
|
|
function Point2D($x, $y) {
|
|
$this->x = $x;
|
|
$this->y = $y;
|
|
}
|
|
|
|
function setLabel($label) {
|
|
$this->label = $label;
|
|
}
|
|
|
|
function getPoint() {
|
|
return array("x" => $this->x,
|
|
"y" => $this->y,
|
|
"label" => $this->label);
|
|
}
|
|
}
|
|
|
|
// "$label" is declared but not defined
|
|
$p1 = new Point2D(1.233, 3.445);
|
|
print_r(get_object_vars($p1));
|
|
|
|
$p1->setLabel("point #1");
|
|
print_r(get_object_vars($p1));
|
|
|
|
?>
|
|
]]>
|
|
</programlisting>
|
|
</example>
|
|
The printout of the above program will be:
|
|
<screen>
|
|
<![CDATA[
|
|
Array
|
|
(
|
|
[x] => 1.233
|
|
[y] => 3.445
|
|
)
|
|
|
|
Array
|
|
(
|
|
[x] => 1.233
|
|
[y] => 3.445
|
|
[label] => point #1
|
|
)
|
|
]]>
|
|
</screen>
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class_methods</function> and
|
|
<function>get_class_vars</function>!
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.get-parent-class">
|
|
<refnamediv>
|
|
<refname>get_parent_class</refname>
|
|
<refpurpose>Retrieves the parent class name for object or class</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>string</type><methodname>get_parent_class</methodname>
|
|
<methodparam><type>mixed</type><parameter>obj</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
If <parameter>obj</parameter> is an object, returns the name of the
|
|
parent class of the class of which <parameter>obj</parameter> is an
|
|
instance.
|
|
</para>
|
|
<para>
|
|
If <parameter>obj</parameter> is a string, returns the name of the parent
|
|
class of the class with that name. This functionality was added in PHP
|
|
4.0.5.
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class</function> and
|
|
<function>is_subclass_of</function>
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.is-a">
|
|
<refnamediv>
|
|
<refname>is_a</refname>
|
|
<refpurpose>
|
|
Returns true if the object is of this class or has this class as
|
|
one of its parents
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>bool</type><methodname>is_a</methodname>
|
|
<methodparam><type>object</type><parameter>object</parameter></methodparam>
|
|
<methodparam><type>string</type><parameter>class_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns &true; if the object is of this class or
|
|
has this class as one of its parents, &false; otherwise.
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class</function>,
|
|
<function>get_parent_class</function>, and
|
|
<function>is_subclass_of</function>.
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.is-subclass-of">
|
|
<refnamediv>
|
|
<refname>is_subclass_of</refname>
|
|
<refpurpose>
|
|
Returns true if the object has this class as one of its parents
|
|
</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>bool</type><methodname>is_subclass_of</methodname>
|
|
<methodparam><type>object</type><parameter>object</parameter></methodparam>
|
|
<methodparam><type>string</type><parameter>class_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns &true; if the object
|
|
<parameter>object</parameter>, belongs to a class which is a
|
|
subclass of <parameter>class_name</parameter>, &false; otherwise.
|
|
</para>
|
|
<simpara>
|
|
See also <function>get_class</function>,
|
|
<function>get_parent_class</function> and
|
|
<function>is_a</function>.
|
|
</simpara>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
<refentry id="function.method-exists">
|
|
<refnamediv>
|
|
<refname>method_exists</refname>
|
|
<refpurpose>Checks if the class method exists</refpurpose>
|
|
</refnamediv>
|
|
<refsect1>
|
|
<title>Description</title>
|
|
<methodsynopsis>
|
|
<type>bool</type><methodname>method_exists</methodname>
|
|
<methodparam><type>object</type><parameter>object</parameter></methodparam>
|
|
<methodparam><type>string</type><parameter>method_name</parameter></methodparam>
|
|
</methodsynopsis>
|
|
<para>
|
|
This function returns &true; if the method given by
|
|
<parameter>method_name</parameter> has been defined for the given
|
|
<parameter>object</parameter>, &false; otherwise.
|
|
</para>
|
|
</refsect1>
|
|
</refentry>
|
|
|
|
</reference>
|
|
|
|
<!-- Keep this comment at the end of the file
|
|
Local variables:
|
|
mode: sgml
|
|
sgml-omittag:t
|
|
sgml-shorttag:t
|
|
sgml-minimize-attributes:nil
|
|
sgml-always-quote-attributes:t
|
|
sgml-indent-step:1
|
|
sgml-indent-data:t
|
|
indent-tabs-mode:nil
|
|
sgml-parent-document:nil
|
|
sgml-default-dtd-file:"../../manual.ced"
|
|
sgml-exposed-tags:nil
|
|
sgml-local-catalogs:nil
|
|
sgml-local-ecat-files:nil
|
|
End:
|
|
vim600: syn=xml fen fdm=syntax fdl=2 si
|
|
vim: et tw=78 syn=sgml
|
|
vi: ts=1 sw=1
|
|
-->
|
|
|