<?xml version="1.0" encoding="UTF-8"?>
<!--
 Licensed to the Apache Software Foundation (ASF) under one or more
 contributor license agreements. See the NOTICE file distributed with
 this work for additional information regarding copyright ownership.
 The ASF licenses this file to You under the Apache License, Version 2.0
 (the "License"); you may not use this file except in compliance with
 the License. You may obtain a copy of the License at
 
         http://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,
 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 See the License for the specific language governing permissions and
 limitations under the License.
-->
<document xmlns="http://maven.apache.org/XDOC/2.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/XDOC/2.0 http://maven.apache.org/xsd/xdoc-2.0.xsd">

	<properties>
		<title>Installing</title>
	</properties>

	<body>
		<section name="Installing">
		
			<subsection name="From source package">
			
				<p>Download the latest source package from the <a href="download.html">download page</a> and unpack it.</p>
			
				<p>The package directory structure is as follows:</p>
			
<pre>
├───apidocs      - API generated documentation
└───src
    ├───assembly - Maven assembly configuration 
    ├───changes  - The change log
    ├───examples - Various usage examples
    ├───main  
    │   └───php  - The main source code
    ├───site     - Web site source
    └───test     - Unit tests
</pre>
				<p>Most users will primarily be interested in the source code which is located in 
				<code>/src/main/php</code>. The contents of this directory may be copied to a directory within your 
				project for easier access.</p>
			
			</subsection>
			
			<subsection name="From PEAR repository">
			
				<p>Apache log4php has it's own <a href="http://pear.apache.org/log4php/index.html">PEAR channel</a>.</p>
				
				<p>To install from the PEAR channel, execute the following commands:</p>
			
<pre>
pear channel-discover pear.apache.org/log4php
pear install log4php/Apache_log4php
</pre>
				
			</subsection>
		</section>
	</body>
</document>
