/class.phpwsdl.php

<?php



/*

PhpWsdl - Generate WSDL from PHP

Copyright (C) 2011  Andreas Müller-Saala, wan24.de 



This program is free software; you can redistribute it and/or modify it under 

the terms of the GNU General Public License as published by the Free Software 

Foundation; either version 3 of the License, or (at your option) any later 

version. 



This program is distributed in the hope that it will be useful, but WITHOUT 

ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 

FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. 



You should have received a copy of the GNU General Public License along with 

this program; if not, see <http://www.gnu.org/licenses/>.

*/



if(basename($_SERVER['SCRIPT_FILENAME'])==basename(__FILE__))

	exit;



// Debugging

/*PhpWsdl::$Debugging=true;// Enable debugging

PhpWsdl::$DebugFile='./cache/debug.log';// The logfile to write the debugging messages to

PhpWsdl::$DebugBackTrace=false;// Include backtrace information in debugging messages?*/



// Initialize PhpWsdl

PhpWsdl::Init();

	

// You don't require class.phpwsdlelement.php and class.phpwsdlcomplex.php, 

// as long as you don't use complex types. So you may comment those two 

// requires out.

// You may also disable loading the class.phpwsdlproxy.php, if you don't plan 

// to use the proxy class for your webservice.

require_once(dirname(__FILE__).'/class.phpwsdlformatter.php');

require_once(dirname(__FILE__).'/class.phpwsdlobject.php');

require_once(dirname(__FILE__).'/class.phpwsdlparser.php');

require_once(dirname(__FILE__).'/class.phpwsdlproxy.php');

require_once(dirname(__FILE__).'/class.phpwsdlparam.php');

require_once(dirname(__FILE__).'/class.phpwsdlmethod.php');

require_once(dirname(__FILE__).'/class.phpwsdlelement.php');

require_once(dirname(__FILE__).'/class.phpwsdlcomplex.php');

require_once(dirname(__FILE__).'/class.phpwsdlenum.php');



// Do things after the environment is configured

PhpWsdl::PostInit();



/**

 * PhpWsdl class

 * 

 * @author Andreas Müller-Saala

 * @copyright Š2011 Andreas Müller-Saala, wan24.de

 * @version 2.4

 */

class PhpWsdl{

	/**

	 * The version number 

	 * 

	 * @var string

	 */

	public static $VERSION='2.4';

	/**

	 * Set this to TRUE to enable the autorun in quick mode

	 * 

	 * @var boolean

	 */

	public static $AutoRun=false;

	/**

	 * Global static configuration

	 * 

	 * @var array

	 */

	public static $Config=Array();

	/**

	 * The webservice handler object

	 * 

	 * @var object

	 */

	public static $ProxyObject=null;

	/**

	 * The current PhpWsdl server

	 * 

	 * @var PhpWsdl

	 */

	public static $ProxyServer=null;

	/**

	 * Use WSDL with the proxy

	 * 

	 * @var boolean

	 */

	public static $UseProxyWsdl=false;

	/**

	 * Type encoding settings

	 * 

	 * @var array

	 */

	public static $TypeEncoding=null;

	/**

	 * Encode return values when using the proxy class?

	 * Note: All encoding have to be defined in the PhpWsdl::$TypeEncoding

	 * 

	 * @var boolean

	 */

	public static $EncodeProxyReturn=false;

	/**

	 * The name

	 * 

	 * @var string

	 */

	public $Name;

	/**

	 * Documentation

	 * 

	 * @var string

	 */

	public $Docs=null;

	/**

	 * The namespace

	 * 

	 * @var string

	 */

	public $NameSpace=null;

	/**

	 * The SOAP endpoint URI

	 * 

	 * @var string

	 */

	public $EndPoint=null;

	/**

	 * Set this to the WSDL URI, if it's different from your SOAP endpoint + "?WSDL"

	 * 

	 * @var string

	 */

	public $WsdlUri=null;

	/**

	 * Set this to the PHP URI, if it's different from your SOAP endpoint + "?PHPSOAPCLIENT"

	 * 

	 * @var string

	 */

	public $PhpUri=null;

	/**

	 * Set this to the HTML documentation URI, if it's different from your SOAP endpoint

	 * 

	 * @var string

	 */

	public $DocUri=null;

	/**

	 * The options for the PHP SoapServer

	 * Note: "actor" and "uri" will be set at runtime

	 * 

	 * @var array

	 */

	public $SoapServerOptions=null;

	/**

	 * An array of file names to parse

	 * 

	 * @var string[]

	 */

	public $Files=Array();

	/**

	 * An array of complex types

	 * 

	 * @var PhpWsdlComplex[]

	 */

	public $Types=null;

	/**

	 * An array of method

	 * 

	 * @var PhpWsdlMethod[]

	 */

	public $Methods=null;

	/**

	 * Remove tabs and line breaks?

	 * Note: Unoptimized WSDL won't be cached

	 * 

	 * @var boolean

	 */

	public $Optimize=true;

	/**

	 * UTF-8 encoded WSDL from the last CreateWsdl method call

	 * 

	 * @var string

	 */

	public $WSDL=null;

	/**

	 * Create a webservice handler class at runtime?

	 * 

	 * @var boolean

	 */

	public $CreateHandler=false;

	/**

	 * The created handler class

	 * 

	 * @var PhpWsdlHandler

	 */

	public $Handler=null;

	/**

	 * The handler class PHP code

	 * 

	 * @var string

	 */

	public $HandlerPhp=null;

	/**

	 * UTF-8 encoded HTML from the last OutputHtml method call

	 * 

	 * @var string

	 */

	public $HTML=null;

	/**

	 * UTF-8 encoded PHP from the last OutputPhp method call

	 * 

	 * @var string

	 */

	public $PHP=null;

	/**

	 * An array of basic types (these are just some of the XSD defined types 

	 * (see http://www.w3.org/TR/2001/PR-xmlschema-2-20010330/)

	 * 

	 * @var string[]

	 */

	public static $BasicTypes=Array(

		'anyType',

		'anyURI',

		'base64Binary',

		'boolean',

		'byte',

		'date',

		'decimal',

		'double',

		'duration',

		'dateTime',

		'float',

		'gDay',

		'gMonth',

		'gMonthDay',

		'gYearMonth',

		'gYear',

		'hexBinary',

		'int',

		'integer',

		'long',

		'NOTATION',

		'number',

		'QName',

		'short',

		'string',

		'time'

	);

	/**

	 * A list of non-nillable types

	 * 

	 * @var string[]

	 */

	public static $NonNillable=Array(

		'boolean',

		'decimal',

		'double',

		'float',

		'int',

		'integer',

		'long',

		'number',

		'short'

	);

	/**

	 * Set this to a writeable folder to enable caching the WSDL in files

	 * 

	 * @var string

	 */

	public static $CacheFolder=null;

	/**

	 * Is the cache folder writeable?

	 * 

	 * @var boolean|NULL

	 */

	public static $CacheFolderWriteAble=null;

	/**

	 * The cache timeout in seconds (set to zero to disable caching, too)

	 * If you set the value to -1, the cache will never expire. Then you have 

	 * to use the PhpWsdl->TidyCache method for cleaning up the cache once 

	 * you've made changes to your webservice.

	 * 

	 * @var int

	 */

	public static $CacheTime=3600;

	/**

	 * Write even unoptimized and/or documented XML to the cache?

	 * 

	 * @var boolean

	 */

	public static $CacheAllWsdl=false;

	/**

	 * Parse documentation?

	 * 

	 * @var boolean

	 */

	public $ParseDocs=true;

	/**

	 * Include documentation tags in WSDL, if the optimizer is disabled?

	 * 

	 * @var boolean

	 */

	public $IncludeDocs=true;

	/**

	 * Force sending WSDL (has a higher priority than PhpWsdl->ForceNotOutputWsdl)

	 * 

	 * @var boolean

	 */

	public $ForceOutputWsdl=false;

	/**

	 * Force NOT sending WSDL (disable sending WSDL, has a higher priority than ?WSDL f.e.)

	 * 

	 * @var boolean

	 */

	public $ForceNotOutputWsdl=false;

	/**

	 * Force sending HTML (has a higher priority than PhpWsdl->ForceNotOutputHtml)

	 * 

	 * @var boolean

	 */

	public $ForceOutputHtml=false;

	/**

	 * Force NOT sending HTML (disable sending HTML)

	 * 

	 * @var boolean

	 */

	public $ForceNotOutputHtml=false;

	/**

	 * The headline for the HTML output or NULL to use the default

	 * 

	 * @var string

	 */

	public $HtmlHeadLine=null;

	/**

	 * Force sending PHP (has a higher priority than PhpWsdl->ForceNotOutputPhp)

	 * 

	 * @var boolean

	 */

	public $ForceOutputPhp=false;

	/**

	 * Force NOT sending PHP (disable sending PHP)

	 * 

	 * @var boolean

	 */

	public $ForceNotOutputPhp=false;

	/**

	 * Regular expression parse a class name

	 * 

	 * @var string

	 */

	public static $classRx='/^.*class\s+([^\s]+)\s*\{.*$/is';

	/**

	 * The HTML2PDF license key (see www.htmltopdf.de)

	 * 

	 * @var string

	 */

	public static $HTML2PDFLicenseKey=null;

	/**

	 * The URI to the HTML2PDF http API

	 * 

	 * @var string

	 */

	public static $HTML2PDFAPI='http://online.htmltopdf.de/';

	/**

	 * The HTML2PDF settings (only available when using a valid license key)

	 * 

	 * @var array

	 */

	public static $HTML2PDFSettings=Array();

	/**

	 * Saves if the sources have been parsed

	 * 

	 * @var boolean

	 */

	public $SourcesParsed=false;

	/**

	 * Saves if the configuration has already been determined

	 * 

	 * @var boolean

	 */

	public $ConfigurationDetermined=false;

	/**

	 * The current PHP SoapServer object

	 * 

	 * @var SoapServer

	 */

	public $SoapServer=null;

	/**

	 * Is a http Auth login required to run the SOAP server?

	 * 

	 * @var boolean

	 */

	public $RequireLogin=false;

	/**

	 * Debugging messages

	 * 

	 * @var string[]

	 */

	public static $DebugInfo=Array();

	/**

	 * En- / Disable the debugging mode

	 * 

	 * @var boolean

	 */

	public static $Debugging=false;

	/**

	 * The debug file to write to

	 * 

	 * @var string

	 */

	public static $DebugFile=null;

	/**

	 * Put backtrace information in debugging messages

	 * 

	 * @var boolean

	 */

	public static $DebugBackTrace=false;

	/**

	 * A debugging handler

	 * 

	 * @var string|array

	 */

	public static $DebugHandler=null;

	/**

	 * WSDL namespaces

	 * 

	 * @var array

	 */

	public static $NameSpaces=null;

	

	/**

	 * PhpWsdl constructor

	 * Note: The quick mode by giving TRUE as first parameter is deprecated and will be removed from version 3.0.

	 * Use PhpWsdl::RunQuickMode() instead

	 * 

	 * @param string|boolean $nameSpace Namespace or NULL to let PhpWsdl determine it, or TRUE to run everything by determining all configuration -> quick mode (default: NULL)

	 * @param string|string[] $endPoint Endpoint URI or NULL to let PhpWsdl determine it - or, in quick mode, the webservice class filename(s) (default: NULL)

	 * @param string $cacheFolder The folder for caching WSDL or NULL to use the systems default (default: NULL)

	 * @param string|string[] $file Filename or array of filenames or NULL (default: NULL)

	 * @param string $name Webservice name or NULL to let PhpWsdl determine it (default: NULL)

	 * @param PhpWsdlMethod[] $methods Array of methods or NULL (default: NULL)

	 * @param PhpWsdlComplex[] $types Array of complex types or NULL (default: NULL)

	 * @param boolean $outputOnRequest Output WSDL on request? (default: FALSE)

	 * @param boolean|string|object|array $runServer Run SOAP server? (default: FALSE)

	 */

	public function PhpWsdl(

		$nameSpace=null,

		$endPoint=null,

		$cacheFolder=null,

		$file=null,

		$name=null,

		$methods=null,

		$types=null,

		$outputOnRequest=false,

		$runServer=false

		){

		// Quick mode

		self::Debug('PhpWsdl constructor called');

		$quickRun=false;

		if($nameSpace===true){

			self::Debug('Quick mode detected');

			$quickRun=true;

			$nameSpace=null;

			if(!is_null($endPoint)){

				if(self::$Debugging)

					self::Debug('Filename(s): '.print_r($endPoint,true));

				$endPoint=null;

			}

		}

		// SOAP server options

		$this->SoapServerOptions=Array(

			'soap_version'	=>	(defined('SOAP_1_2'))?SOAP_1_2:SOAP_1_1,

			'encoding'		=>	'UTF-8',

			'compression'	=>	SOAP_COMPRESSION_ACCEPT|SOAP_COMPRESSION_GZIP|9

		);

		// Optimizer settings

		$this->Optimize=!isset($_GET['readable']);// Call with "?WSDL&readable" to get human readable WSDL

		self::Debug('Optimizer is '.(($this->Optimize)?'enabled':'disabled'));

		// Cache settings

		if(!is_null($cacheFolder)){

			self::Debug('Cache folder is '.$cacheFolder);

			self::$CacheFolder=$cacheFolder;

		}

		// Namespace

		$this->NameSpace=(is_null($nameSpace))?$this->DetermineNameSpace():$nameSpace;

		self::Debug('Namespace is '.$this->NameSpace);

		// Endpoint

		$this->EndPoint=((!is_null($endPoint)))?$endPoint:$this->DetermineEndPoint();

		self::Debug('Endpoint is '.$this->EndPoint);

		// Name

		if(!is_null($name)){

			self::Debug('Name is '.$name);

			$this->Name=$name;

		}

		// Source files

		if(!is_null($file)){

			if(self::$Debugging)

				self::Debug('Filename(s): '.print_r($file,true));

			$this->Files=array_merge($this->Files,(is_array($file))?$file:Array($file));

		}

		// Methods

		$this->Methods=(!is_null($methods))?$methods:Array();

		if(sizeof($this->Methods)>0&&self::$Debugging)

			self::Debug('Methods: '.print_r($this->Methods,true));

		// Types

		$this->Types=(!is_null($types))?$types:Array();

		if(sizeof($this->Types)>0&&self::$Debugging)

			self::Debug('Types: '.print_r($this->Types,true));

		// Constructor hook

		self::CallHook(

			'ConstructorHook',

			Array(

				'server'		=>	$this,

				'output'		=>	&$outputOnRequest,

				'run'			=>	&$runServer,

				'quickmode'		=>	&$quickRun

			)

		);

		// WSDL output

		if($outputOnRequest&&!$runServer)

			$this->OutputWsdlOnRequest();

		// Run the server

		if($quickRun||$runServer)

			$this->RunServer(null,(is_bool($runServer))?null:$runServer);

	}

	

	/**

	 * Create an instance of PhpWsdl

	 * Note: The quick mode by giving TRUE as first parameter is deprecated and will be removed from version 3.0.

	 * Use PhpWsdl::RunQuickMode() instead

	 * 

	 * @param string|boolean $nameSpace Namespace or NULL to let PhpWsdl determine it, or TRUE to run everything by determining all configuration -> quick mode (default: NULL)

	 * @param string|string[] $endPoint Endpoint URI or NULL to let PhpWsdl determine it - or, in quick mode, the webservice class filename(s) (default: NULL)

	 * @param string $cacheFolder The folder for caching WSDL or NULL to use the systems default (default: NULL)

	 * @param string|string[] $file Filename or array of filenames or NULL (default: NULL)

	 * @param string $name Webservice name or NULL to let PhpWsdl determine it (default: NULL)

	 * @param PhpWsdlMethod[] $methods Array of methods or NULL (default: NULL)

	 * @param PhpWsdlComplex[] $types Array of complex types or NULL (default: NULL)

	 * @param boolean $outputOnRequest Output WSDL on request? (default: FALSE)

	 * @param boolean|string|object|array $runServer Run SOAP server? (default: FALSE)

	 * @return PhpWsdl The PhpWsdl object

	 */

	public static function CreateInstance(

		$nameSpace=null,

		$endPoint=null,

		$cacheFolder=null,

		$file=null,

		$name=null,

		$methods=null,

		$types=null,

		$outputOnRequest=false,

		$runServer=false

		){

		self::Debug('Create new PhpWsdl instance');

		$obj=null;

		self::CallHook(

			'BeforeCreateInstanceHook',

			Array(

				'server'		=>	&$obj,

				'namespace'		=>	&$nameSpace,

				'endpoint'		=>	&$endPoint,

				'cachefolder'	=>	&$cacheFolder,

				'file'			=>	&$file,

				'name'			=>	&$name,

				'methods'		=>	&$methods,

				'types'			=>	&$types,

				'outputonrequest'=>	&$outputOnRequest,

				'runserver'		=>	&$runServer

			)

		);

		if(is_null($obj))

			$obj=new PhpWsdl($nameSpace,$endPoint,$cacheFolder,$file,$name,$methods,$types,$outputOnRequest,$runServer);

		self::CallHook(

			'CreateInstanceHook',

			Array(

				'server'		=>	&$obj

			)

		);

		return $obj;

	}

	

	/**

	 * Run the PhpWsdl SOAP server in quick mode

	 * 

	 * @param string|string[] $file The webservice handler class file or a list of files or NULL (default: NULL)

	 */

	public static function RunQuickMode($file=null){

		self::Debug('Run quick mode');

		$server=self::CreateInstance();

		if(!is_null($file))

			$server->Files=(is_array($file))?$file:Array($file);

		$server->RunServer();

	}

	

	/**

	 * Determine if WSDL was requested by the client

	 * 

	 * @return boolean WSDL requested?

	 */

	public function IsWsdlRequested(){

		return $this->ForceOutputWsdl||((isset($_GET['wsdl'])||isset($_GET['WSDL']))&&!$this->ForceNotOutputWsdl);

	}

	

	/**

	 * Determine if HTML was requested by the client

	 * 

	 * @return boolean HTML requested?

	 */

	public function IsHtmlRequested(){

		return $this->ForceOutputHtml||(strlen(file_get_contents('php://input'))<1&&!$this->ForceNotOutputHtml);

	}



	/**

	 * Determine if PHP was requested by the client

	 * 

	 * @return boolean PHP requested?

	 */

	public function IsPhpRequested(){

		return $this->ForceOutputPhp||((isset($_GET['phpsoapclient'])||isset($_GET['PHPSOAPCLIENT']))&&!$this->ForceNotOutputPhp);

	}



	/**

	 * Determine if this request is a SOAP request

	 * 

	 * @return boolean

	 */

	public function IsSoapRequest(){

		return !$this->IsHtmlRequested()&&!$this->IsWsdlRequested()&&!$this->IsPhpRequested();

	}



	/**

	 * Determine if only global methods are served

	 * 

	 * @return boolean Only global methods?

	 */

	public function IsOnlyGlobal(){

		$res=true;

		$i=-1;

		$len=sizeof($this->Methods);

		while(++$i<$len)

			if(!$this->Methods[$i]->IsGlobal){

				$res=false;

				break;

			}

		return $res;

	}

	

	/**

	 * Disble caching

	 * 

	 * @param bool $allCaching Do not only set the timeout to zero? (default: TRUE)

	 */

	public static function DisableCache($allCaching=true){

		self::Debug('Disable '.(($allCaching)?'all':'this').' caching');

		if($allCaching)

			self::$CacheFolder=null;

		if(!$allCaching)

			self::$CacheTime=0;

	}

	

	/**

	 * Enable caching

	 * 

	 * @param string $folder The cache folder or NULL to use a system temporary directory (default: NULL)

	 * @param int $timeout The caching timeout in seconds or NULL to use the previous value or the default (3600) (default: NULL)

	 */

	public static function EnableCache($folder=null,$timeout=null){

		if(is_null($folder)&&is_null(self::$CacheFolder)){

			if(self::IsCacheFolderWriteAble('./cache')){

				$folder='./cache';

			}else if(self::IsCacheFolderWriteAble(dirname(__FILE__).'/cache')){

				$folder=dirname(__FILE__).'/cache';

			}else if(self::IsCacheFolderWriteAble(sys_get_temp_dir())){

				$folder=sys_get_temp_dir();

			}else{

				self::Debug('Could not find a cache folder');

			}

		}

		if(is_null($timeout))

			$timeout=(self::$CacheTime!=0)?self::$CacheTime:3600;

		self::Debug('Enable cache in folder "'.((is_null($folder))?'(none)':$folder).'" with timeout '.$timeout.' seconds');

		self::$CacheFolder=$folder;

		self::$CacheTime=$timeout;

	}

	

	/**

	 * Determine the configuration

	 * 

	 * @return boolean Succeed?

	 */

	public function DetermineConfiguration(){

		if(!is_null($this->GetWsdlFromCache()))

			return true;

		$this->ParseSource();

		$mLen=sizeof($this->Methods);

		$tLen=sizeof($this->Types);

		$fLen=sizeof($this->Files);

		if($this->ConfigurationDetermined)

			return ($mLen>0||$tLen>0)&&!is_null($this->Name);

		self::Debug('Determine configuration');

		$this->ConfigurationDetermined=true;

		$tryWebService=

			!$this->IsFileInList('class.webservice.php')&&

			(

				file_exists('class.webservice.php')||

				file_exists(dirname(__FILE__).'/class.webservice.php')

			);

		// No methods or types? Try to parse them from the current script

		if($mLen<1&&$tLen<1){

			$tryFiles=Array();

			if($tryWebService){

				if(file_exists('class.webservice.php'))

					$tryFiles[]='class.webservice.php';

				if(file_exists(dirname(__FILE__).'/class.webservice.php'))

					$tryFiles[]=dirname(__FILE__).'/class.webservice.php';

			}

			if(!$this->IsFileInList($_SERVER['SCRIPT_FILENAME']))

				$tryFiles[]=$_SERVER['SCRIPT_FILENAME'];

			$i=-1;

			$len=sizeof($tryFiles);

			while(++$i<$len){

				$file=$tryFiles[$i];

				self::Debug('Try to load objects from '.$file);

				$this->ParseSource(false,file_get_contents($file));

				$mLen=sizeof($this->Methods);

				$tLen=sizeof($this->Types);

				if($mLen<1&&$tLen<1)

					continue;

				self::Debug('Found objects, adding the file to list');

				$this->Files[]=$file;

				$fLen++;

				break;

			}

			if($mLen<1&&$tLen<1)

				return false;

		}

		// No class name? Try to parse one from the current files

		if(!is_null($this->Name))

			return true;

		$tryFiles=Array();

		if(!$this->IsFileInList($_SERVER['SCRIPT_FILENAME']))

			$tryFiles[]=$_SERVER['SCRIPT_FILENAME'];

		if($tryWebService){

			if(file_exists('class.webservice.php'))

				$tryFiles[]='class.webservice.php';

			if(file_exists(dirname(__FILE__).'/class.webservice.php'))

				$tryFiles[]=dirname(__FILE__).'/class.webservice.php';

		}

		$tryFiles=array_merge($this->Files,$tryFiles);

		$i=-1;

		$len=sizeof($tryFiles);

		$class=null;

		while(++$i<$len){

			$file=$tryFiles[$i];

			self::Debug('Try to determine the class name from '.$file);

			$temp=file_get_contents($file);

			if(!preg_match(self::$classRx,$temp))

				continue;

			$class=preg_replace(self::$classRx,"$1",$temp);

			self::Debug('Found class name '.$class);

			break;

		}

		// No class name yet? Use the default if only global methods are present

		if(is_null($class)&&$this->IsOnlyGlobal()){

			self::Debug('Using default webservice name');

			$class='SoapWebService';

		}

		$this->Name=$class;

		return !is_null($class);

	}

	

	/**

	 * Determine the endpoint URI

	 */

	public function DetermineEndPoint(){

		$ssl=isset($_SERVER['HTTPS'])&&$_SERVER['HTTPS']=='on';

		$res='http'.(($ssl)?'s':'').'://'.$_SERVER['SERVER_NAME'];

		if(((!$ssl&&$_SERVER['SERVER_PORT']!=80)||($ssl&&$_SERVER['SERVER_PORT']!=443)))

			$res.=':'.$_SERVER['SERVER_PORT'];// Append the non-default server port

		return $res.$_SERVER['SCRIPT_NAME'];

	}



	/**

	 * Determine the namespace

	 */

	public function DetermineNameSpace(){

		return 'http://'.$_SERVER['SERVER_NAME'].str_replace(basename($_SERVER['SCRIPT_NAME']),'',$_SERVER['SCRIPT_NAME']);

	}

	

	/**

	 * Determine if a file is included in the list of files

	 * 

	 * @param string $file The filename

	 * @return boolean In the list?

	 */

	public function IsFileInList($file){

		$file=preg_quote(basename($file));

		$i=-1;

		$fLen=sizeof($this->Files);

		while(++$i<$fLen)

			if(preg_match('/^(.*\/)?'.$file.'$/i',$this->Files[$i]))

				return true;

		return false;

	}

	

	/**

	 * Determine if a type is used as exception type for a method

	 * 

	 * @param string|PhpWsdlComplex $type A type name or object instance

	 * @return boolean Used as exception type?

	 */

	public function IsException($type){

		if(is_object($type))

			$type=$type->Name;

		if(PhpWsdlMethod::$DefaultException==$type)

			return true;

		$i=-1;

		$len=sizeof($this->Methods);

		while(++$i<$len)

			if($this->Methods[$i]->Exception==$type)

				return true;

		return false;

	}

	

	/**

	 * Create the WSDL

	 * 

	 * @param boolean $reCreate Don't use the cached WSDL? (default: FALSE)

	 * @param boolean $optimize If TRUE, override the PhpWsdl->Optimizer property and force optimizing (default: FALSE)

	 * @return string The UTF-8 encoded WSDL as string

	 */

	public function CreateWsdl($reCreate=false,$optimizer=false){

		self::Debug('Create WSDL');

		// Ask the cache

		if(!$reCreate&&(self::$CacheAllWsdl||!$this->IncludeDocs||$optimizer||$this->Optimize)){

			self::Debug('Try to get WSDL from the cache');

			$wsdl=$this->GetWsdlFromCache();

			if(!is_null($wsdl)){

				self::Debug('Using cached WSDL');

				return (!$optimizer&&!$this->Optimize)?self::FormatXml($wsdl):$wsdl;

			}

		}

		// Prepare the WSDL generator

		if(!$this->DetermineConfiguration()){

			$mLen=sizeof($this->Methods);

			$tLen=sizeof($this->Types);

			if($mLen<1&&$tLen<1){

				self::Debug('No methods and types');

				throw(new Exception('No methods and no complex types are available'));

			}

			if(is_null($this->Name)){

				self::Debug('No name');

				throw(new Exception('Could not determine webservice handler class name'));

			}

		}

		$res=Array();

		// Create the XML Header

		self::CallHook(

			'CreateWsdlHeaderHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Create types

		self::CallHook(

			'CreateWsdlTypeSchemaHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Create messages

		self::CallHook(

			'CreateWsdlMessagesHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Create port types

		self::CallHook(

			'CreateWsdlPortsHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Create bindings

		self::CallHook(

			'CreateWsdlBindingsHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Create the service

		self::CallHook(

			'CreateWsdlServiceHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Finish the WSDL XML string

		self::CallHook(

			'CreateWsdlFooterHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Run the optimizer

		self::CallHook(

			'CreateWsdlOptimizeHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'optimizer'		=>	&$optimizer

			)

		);

		// Fill the cache

		if(self::$CacheAllWsdl||!$this->IncludeDocs||$optimizer||$this->Optimize){

			self::Debug('Cache created WSDL');

			$this->WriteWsdlToCache(

				(

					!self::$CacheAllWsdl&&

					!$optimizer&&

					!$this->Optimize

				)

					?self::OptimizeXml($res)

					:$res

				,

				null,

				null,

				true

			);

		}

		return $this->WSDL;

	}



	/**

	 * Create header

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlHeader($data){

		self::Debug('CreateWsdlHeader');

		$res=&$data['res'];

		$server=$data['server'];

		$res[]='<?xml version="1.0" encoding="UTF-8"?>';

		$temp=Array();

		$keys=array_keys(self::$NameSpaces);

		$i=-1;

		$len=sizeof($keys);

		while(++$i<$len)

			$temp[]='xmlns:'.$keys[$i].'="'.self::$NameSpaces[$keys[$i]].'"';

		$res[]='<wsdl:definitions xmlns:tns="'.$server->NameSpace.'" targetNamespace="'.$server->NameSpace.'" '.implode(' ',$temp).'>';

		return true;

	}

	

	/**

	 * Create type schema

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlTypeSchema($data){

		self::Debug('CreateWsdlTypeSchema');

		$res=&$data['res'];

		$server=$data['server'];

		$tLen=sizeof($server->Types);

		if($tLen>0){

			$res[]='<wsdl:types>';

			$res[]='<s:schema targetNamespace="'.$server->NameSpace.'">';

			$i=-1;

			while(++$i<$tLen)

				$res[]=$server->Types[$i]->CreateType($server);

			self::CallHook(

				'CreateWsdlTypesHook',

				$data

			);

			$res[]='</s:schema>';

			$res[]='</wsdl:types>';

		}

		return true;

	}

	

	/**

	 * Create messages

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlMessages($data){

		self::Debug('CreateWsdlMessages');

		$res=&$data['res'];

		$server=$data['server'];

		$i=-1;

		$mLen=sizeof($server->Methods);

		while(++$i<$mLen)

			$res[]=$server->Methods[$i]->CreateMessages($server);

		return true;

	}

	

	/**

	 * Create port types

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlPorts($data){

		self::Debug('CreateWsdlPorts');

		$res=&$data['res'];

		$server=$data['server'];

		$res[]='<wsdl:portType name="'.$server->Name.'Soap">';

		$i=-1;

		$mLen=sizeof($server->Methods);

		while(++$i<$mLen)

			$res[]=$server->Methods[$i]->CreatePortType($server);

		self::CallHook(

			'CreateWsdlPortsAddHook',

			$data

		);

		$res[]='</wsdl:portType>';

		return true;

	}

	

	/**

	 * Create bindings

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlBindings($data){

		self::Debug('CreateWsdlBindings');

		$res=&$data['res'];

		$server=$data['server'];

		$res[]='<wsdl:binding name="'.$server->Name.'Soap" type="tns:'.$server->Name.'Soap">';

		$res[]='<soap:binding transport="http://schemas.xmlsoap.org/soap/http" style="rpc" />';

		$i=-1;

		$mLen=sizeof($server->Methods);

		while(++$i<$mLen)

			$res[]=$server->Methods[$i]->CreateBinding($server);

		self::CallHook(

			'CreateWsdlBindingsAddHook',

			$data

		);

		$res[]='</wsdl:binding>';

		return true;

	}

	

	/**

	 * Create service port

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlService($data){

		self::Debug('CreateWsdlService');

		$res=&$data['res'];

		$server=$data['server'];

		$res[]='<wsdl:service name="'.$server->Name.'">';

		if($server->IncludeDocs&&!$server->Optimize&&!is_null($server->Docs))

			$res[]='<wsdl:documentation><![CDATA['.$server->Docs.']]></wsdl:documentation>';

		$res[]='<wsdl:port name="'.$server->Name.'Soap" binding="tns:'.$server->Name.'Soap">';

		$res[]='<soap:address location="'.$server->EndPoint.'" />';

		$res[]='</wsdl:port>';

		self::CallHook(

			'CreateWsdlServiceAddHook',

			$data

		);

		$res[]='</wsdl:service>';

		return true;

	}

	

	/**

	 * Create footer

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlFooter($data){

		self::Debug('CreateWsdlFooter');

		$res=&$data['res'];

		$res[]='</wsdl:definitions>';

		return true;

	}



	/**

	 * Optimize WSDL

	 * 

	 * @param array $data Data array

	 * @return boolean Response

	 */

	public static function CreateWsdlOptimize($data){

		self::Debug('CreateWsdlOptimize');

		$res=&$data['res'];

		$server=$data['server'];

		$optimizer=&$data['optimizer'];

		$res=utf8_encode(implode('',$res));

		$res=(!$optimizer&&!$server->Optimize)

			?self::FormatXml($res)

			:self::OptimizeXml($res);

		$server->WSDL=$res;

		return true;

	}

	

	/**

	 * Remove tabs and newline from XML

	 * 

	 * @param string $xml The unoptimized XML

	 * @return string The optimized XML

	 */

	public static function OptimizeXml($xml){

		self::Debug('Optimize XML');

		return preg_replace('/[\n|\t]/','',$xml);

	}

	

	/**

	 * Format XML human readable

	 * 

	 * @param string $xml The XML

	 * @return string Human readable XML

	 */

	public static function FormatXml($xml){

		self::Debug('Produce human readable XML');

		$input=fopen('data://text/plain,'.$xml,'r');

		$output=fopen('php://temp','w');

		$xf=new PhpWsdlFormatter($input,$output);

		$xf->format();

		rewind($output);

		$xml=stream_get_contents($output);

		fclose($input);

		fclose($output);

		return $xml;

	}

	

	/**

	 * Interpret the @service keyword

	 * 

	 * @param $data The parser data

	 * @return boolean Response

	 */

	public static function InterpretService($data){

		self::Debug('Interpret service');

		$server=$data['server'];

		$info=explode(' ',$data['keyword'][1],2);

		if(sizeof($info)<1){

			self::Debug('WARNING:  Invalid service definition');

			return true;

		}

		$server->Name=$info[0];

		if($server->ParseDocs&&sizeof($info)>1&&is_null($server->Docs))

			$server->Docs=$info[1];

		return true;

	}

	

	/**

	 * Interpret a setting

	 * 

	 * @param array $data The parser data

	 * @return boolean Response

	 */

	public static function InterpretSetting($data){

		$info=explode(' ',$data['keyword'][1],2);

		if(sizeof($info)<1)

			return true;

		self::Debug('Interpret setting '.$info[0]);

		$info=explode('=',$info[0],2);

		if(sizeof($info)>1){

			$data['settings'][$info[0]]=$info[1];

		}else if(isset($data['settings'][$info[0]])){

			unset($data['settings'][$info[0]]);

		}

		return false;

	}

	

	/**

	 * Parse source files for WSDL definitions in comments

	 * 

	 * @param boolean $init Empty the Methods and the Types properties? (default: FALSE)

	 * @param string $str Source string or NULL to parse the defined files (default: NULL)

	 */

	public function ParseSource($init=false,$str=null){

		self::Debug('Parse the source');

		if($init){

			self::Debug('Init methods and types');

			$this->Methods=Array();

			$this->Types=Array();

			$this->SourcesParsed=false;

		}

		if(is_null($str)){

			if($this->SourcesParsed)

				return;

			self::Debug('Load source files');

			$this->SourcesParsed=true;

			$fLen=sizeof($this->Files);

			if($fLen<1)

				return;

			// Load the source

			$src=Array();

			$i=-1;

			while(++$i<$fLen)

				$src[]=trim(file_get_contents($this->Files[$i]));

		}else{

			self::Debug('Use given string');

			$src=Array($str);

		}

		// Parse the source

		self::Debug('Run the parser');

		$parser=new PhpWsdlParser($this);

		$parser->Parse(implode("\n",$src));

	}

	

	/**

	 * Output the WSDL to the client

	 * 

	 * @param boolean $withHeaders Output XML headers? (default: TRUE)

	 */

	public function OutputWsdl($withHeaders=true){

		if(!self::CallHook(

				'OutputWsdlHook',

				Array(

					'server'		=>	$this

				)

			)

		)

			return;

		self::Debug('Output WSDL');

		if($withHeaders)

			header('Content-Type: text/xml; charset=UTF-8',true);

		echo $this->CreateWsdl();

	}



	/**

	 * Output the WSDL to the client, if requested

	 * 

	 * @param boolean $andExit Exit after sending WSDL? (default: TRUE)

	 * @return boolean Has the WSDL been sent to the client?

	 */

	public function OutputWsdlOnRequest($andExit=true){

		if(!$this->IsWsdlRequested())

			return false;

		$this->OutputWsdl();

		if($andExit){

			self::Debug('Exit script execution');

			exit;

		}

		return true;

	}

	

	/**

	 * Output the HTML to the client

	 * 

	 * @param boolean $withHeaders Send HTML headers? (default: TRUE)

	 * @param boolean $echo Print HTML (default: TRUE)

	 * @param boolean $cache Cache the result (default: TRUE);

	 * @return string The HTML

	 */

	public function OutputHtml($withHeaders=true,$echo=true,$cache=true){

		self::Debug('Output HTML');

		if(sizeof($this->Methods)<1)

			$this->CreateWsdl();

		if(!self::CallHook(

				'OutputHtmlHook',

				Array(

					'server'		=>	$this

				)

			)

		)

			return;

		// Header

		if($withHeaders)

			header('Content-Type: text/html; charset=UTF-8',true);

		$this->GetWsdlFromCache();

		if(!is_null($this->HTML)){

			if($echo)

				echo $this->HTML;

			return $this->HTML;

		}

		$res=Array();

		$res[]='<html>';

		$res[]='<head>';

		$res[]='<title>'.((is_null($this->HtmlHeadLine))?$this->Name.' interface description':nl2br(htmlentities($this->HtmlHeadLine))).'</title>';

		$res[]='<style type="text/css" media="all">';

		$res[]='body{font-family:Calibri,Arial;background-color:#fefefe;}';

		$res[]='.pre{font-family:Courier;}';

		$res[]='.normal{font-family:Calibri,Arial;}';

		$res[]='.bold{font-weight:bold;}';

		$res[]='h1,h2,h3{font-family:Verdana,Times;}';

		$res[]='h1{border-bottom:1px solid gray;}';

		$res[]='h2{border-bottom:1px solid silver;}';

		$res[]='h3{border-bottom:1px dashed silver;}';

		$res[]='a{text-decoration:none;}';

		$res[]='a:hover{text-decoration:underline;}';

		$res[]='.blue{color:#3400FF;}';

		$res[]='.lightBlue{color:#5491AF;}';

		if(!is_null(self::$HTML2PDFLicenseKey)&&self::$HTML2PDFSettings['attachments']=='1')

			$res[]='.print{display:none;}';

		self::CallHook(

			'CreateHtmlCssHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res

			)

		);

		$res[]='</style>';

		$res[]='<style type="text/css" media="print">';

		$res[]='.noprint{display:none;}';

		if(!is_null(self::$HTML2PDFLicenseKey)&&self::$HTML2PDFSettings['attachments']=='1')

			$res[]='.print{display:block;}';

		self::CallHook(

			'CreateHtmlCssPrintHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res

			)

		);

		$res[]='</style>';

		$res[]='</head>';

		$res[]='<body>';

		$types=$this->SortObjectsByName($this->Types);

		$methods=$this->SortObjectsByName($this->Methods);

		// General information

		self::CallHook(

			'CreateHtmlGeneralHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'methods'		=>	&$methods,

				'types'			=>	&$types

			)

		);

		// Index

		self::CallHook(

			'CreateHtmlIndexHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'methods'		=>	&$methods,

				'types'			=>	&$types

			)

		);

		// Complex types

		self::CallHook(

			'CreateHtmlComplexTypesHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'methods'		=>	&$methods,

				'types'			=>	&$types

			)

		);

		// Methods

		self::CallHook(

			'CreateHtmlMethodsHook',

			Array(

				'server'		=>	$this,

				'res'			=>	&$res,

				'methods'		=>	&$methods,

				'types'			=>	&$types

			)

		);

		// HTML2PDF link

		$param=Array(

			'plain'			=>	'1',

			'filename'		=>	$this->Name.'-webservices.pdf',

			'print'			=>	'1'

		);

		if(!is_null(self::$HTML2PDFLicenseKey)){

			// Use advanced HTML2PDF API

			$temp=array_merge(self::$HTML2PDFSettings,Array(

				'url'			=>	$this->GetDocUri()

			));

			if($temp['attachments']=='1'){

				$cnt=0;

				if(!$this->ForceNotOutputWsdl){

					$cnt++;

					$temp['attachment_'.$cnt]=$this->Name.'.wsdl:'.$this->GetWsdlUri();

					if($this->ParseDocs&&$this->IncludeDocs){

						$cnt++;

						$temp['attachment_'.$cnt]=$this->Name.'-doc.wsdl:'.$this->GetWsdlUri().'&readable';

					}

				}

				if(!$this->ForceNotOutputPhp){

					$cnt++;

					$temp['attachment_'.$cnt]=$this->Name.'.soapclient.php:'.$this->GetPhpUri();

				}

				self::CallHook(

					'PdfAttachmentHook',

					Array(

						'server'		=>	$this,

						'cnt'			=>	&$cnt,

						'param'			=>	&$temp,

						'res'			=>	&$res,

						'methods'		=>	&$methods,

						'types'			=>	&$types

					)

				);

				if($cnt<1)

					unset($temp['attachments']);

			}

			$options=Array();

			$keys=array_keys($temp);

			$i=-1;

			$len=sizeof($keys);

			while(++$i<$len)

				$options[]=$keys[$i].'='.$temp[$keys[$i]];

			$options='$'.base64_encode(implode("\n",$options));

			$license=sha1(self::$HTML2PDFLicenseKey.self::$HTML2PDFLicenseKey).'-'.sha1($options.self::$HTML2PDFLicenseKey);

			$param['url']=$options;

			$param['license']=$license;

		}

		$temp=$param;

		$param=Array();

		$keys=array_keys($temp);

		$i=-1;

		$len=sizeof($keys);

		while(++$i<$len)

			$param[]=urlencode($keys[$i]).'='.urlencode($temp[$keys[$i]]);

		$pdfLink=self::$HTML2PDFAPI.'?'.implode('&',$param);

		// Footer

		$res[]='<hr>';

		$res[]='<p><small>Powered by <a href="http://code.google.com/p/php-wsdl-creator/">PhpWsdl</a><span class="noprint"> - PDF download: <a href="'.$pdfLink.'">Download this page as PDF</a></span></small></p>';

		$res[]='</body>';

		$res[]='</html>';

		// Clean up the generated HTML and send it

		$res=implode("\n",$res);

		$res=str_replace('<br />','<br>',$res);// Because nl2br will produce XHTML (and nothing if the second parameter is FALSE!?)

		if(!self::CallHook(

				'SendHtmlHook',

				Array(

					'server'		=>	$this,

					'res'			=>	&$res

				)

			)

		)

			return;

		$res=utf8_encode($res);

		$this->HTML=$res;

		if($cache)

			$this->WriteWsdlToCache(null,null,null,true);

		if($echo)

			echo $res;

		return $res;

	}

	

	/**

	 * Create general information

	 * 

	 * @param array $data The information object

	 * @return boolean Response

	 */

	public static function CreateHtmlGeneral($data){

		self::Debug('CreateHtmlGeneral');

		$res=&$data['res'];

		$server=$data['server'];

		$res[]='<h1>'.$server->Name.' SOAP WebService interface description</h1>';

		$res[]='<p>Endpoint URI: <span class="pre">'.$server->EndPoint.'</span></p>';

		if(!$server->ForceNotOutputWsdl)

			$res[]='<p>WSDL URI: <span class="pre"><a href="'.$server->GetWsdlUri().'&readable">'.$server->GetWsdlUri().'</a></span></p>';

		if(!$server->ForceNotOutputPhp)

			$res[]='<p>PHP SOAP client download URI: <span class="pre"><a href="'.$server->GetPhpUri().'">'.$server->GetPhpUri().'</a></span></p>';

		//FIXME There may be attachments if a hooking method (PdfAttachmentHook) adds a file!

		if(self::$HTML2PDFSettings['attachments']=='1'&&!is_null(self::$HTML2PDFLicenseKey)&&($server->ForceNotOutputWsdl||$server->ForceNotOutputPhp))

			$res[]='<p class="print">Additional files are attached to this PDF documentation.</p>';

		if(!is_null($server->Docs))

			$res[]='<p>'.nl2br(htmlentities($server->Docs)).'</p>';

		return true;

	}

	

	/**

	 * Create table of contents

	 * 

	 * @param array $data The information object

	 * @return boolean Response

	 */

	public static function CreateHtmlIndex($data){

		self::Debug('CreateHtmlIndex');

		$res=&$data['res'];

		$types=&$data['types'];

		$methods=&$data['methods'];

		$tLen=sizeof($types);

		$mLen=sizeof($methods);

		$res[]='<div class="noprint">';

		$res[]='<h2>Index</h2>';

		if($tLen>0){

			$res[]='<p>Exported types:</p>';

			$i=-1;

			$res[]='<ul>';

			while(++$i<$tLen)

				$res[]='<li><a href="#'.$types[$i]->Name.'"><span class="pre">'.$types[$i]->Name.'</span></a></li>';

			$res[]='</ul>';

		}

		if($mLen>0){

			$res[]='<p>Public methods:</p>';

			$i=-1;

			$res[]='<ul>';

			while(++$i<$mLen)

				$res[]='<li><a href="#'.$methods[$i]->Name.'"><span class="pre">'.$methods[$i]->Name.'</span></a></li>';

			$res[]='</ul>';

		}

		$res[]='</div>';

		return true;

	}

	

	/**

	 * Create method list

	 * 

	 * @param array $data The information object

	 * @return boolean Response

	 */

	public static function CreateHtmlMethods($data){

		self::Debug('CreateHtmlMethods');

		$res=&$data['res'];

		$methods=&$data['methods'];

		$mLen=sizeof($methods);

		if($mLen>0){

			$res[]='<h2>Public methods</h2>';

			$i=-1;

			while(++$i<$mLen)

				$methods[$i]->CreateMethodHtml(array_merge(

					$data,

					Array(

						'method'		=>	$methods[$i]

					)

				));

		}

		return true;

	}



	/**

	 * Create complex types list

	 * 

	 * @param array $data The information object

	 * @return boolean Response

	 */

	public static function CreateHtmlComplexTypes($data){

		self::Debug('CreateHtmlComplexTypes');

		$res=&$data['res'];

		$types=&$data['types'];

		$server=$data['server'];

		$tLen=sizeof($server->Types);

		if($tLen>0){

			$res[]='<h2>Exported types</h2>';

			$i=-1;

			while(++$i<$tLen)

				$types[$i]->CreateTypeHtml(array_merge(

					$data,

					Array(

						'type'			=>	$types[$i]

					)

				));

		}

		return true;

	}

	

	/**

	 * Sort objects by name

	 * 

	 * @param PhpWsdlComplex[]|PhpWsdlMethod[] $obj

	 * @return PhpWsdlComplex[]|PhpWsdlMethod[] Sorted objects

	 */

	public function SortObjectsByName($obj){

		self::Debug('Sort objects by name');

		$temp=Array();

		$i=-1;

		$len=sizeof($obj);

		while(++$i<$len)

			$temp[$obj[$i]->Name]=$obj[$i];

		$keys=array_keys($temp);

		sort($keys);

		$res=Array();

		$i=-1;

		while(++$i<$len)

			$res[]=$temp[$keys[$i]];

		return $res;

	}

	

	/**

	 * Output the HTML to the client, if requested

	 * 

	 * @param boolean $andExit Exit after sending HTML? (default: TRUE)

	 * @return boolean Has the HTML been sent to the client?

	 */

	public function OutputHtmlOnRequest($andExit=true){

		if(!$this->IsHtmlRequested())

			return false;

		$this->OutputHtml();

		if($andExit){

			self::Debug('Exit script execution');

			exit;

		}

		return true;

	}

	

	/**

	 * Output the PHP SOAP client source for this webservice

	 * 

	 * @param boolean $withHeaders Send text headers? (default: TRUE)

	 * @param boolean $echo Print source (default: TRUE)

	 * @param array $options Options array (default: array)

	 * @param boolean $cache Cache the result (default: TRUE);

	 * @return string PHP source

	 */

	public function OutputPhp($withHeaders=true,$echo=true,$options=Array(),$cache=true){

		self::Debug('Output PHP');

		if(sizeof($this->Methods)<1)

			$this->CreateWsdl();

		if(!self::CallHook(

				'OutputPhpHook',

				Array(

					'server'		=>	$this,

					'withHeaders'	=>	&$withHeaders,

					'echo'			=>	&$echo,

					'options'		=>	&$options

				)

			)

		)

			return '';

		// Options

		$hasOptions=sizeof(array_keys($options))>0;

		if(!isset($options['class']))

			$options['class']=$this->Name.'SoapClient';

		if(!isset($options['openphp']))

			$options['openphp']=true;

		if(!isset($options['phpclient']))

			$options['phpclient']=true;

		$data=Array(

			'server'		=>	$this,

			'withHeaders'	=>	&$withHeaders,

			'echo'			=>	&$echo,

			'options'		=>	&$options,

			'res'			=>	&$res

		);

		// Header

		if($withHeaders){

			header('Content-Type: text/plain; charset=UTF-8',true);

			header('Content-Disposition: attachment; filename='.$options['class'].'.php');

		}

		if(!$hasOptions){

			if(is_null($this->PHP))

				$this->GetWsdlFromCache();

			if(!is_null($this->PHP)){

				if($echo)

					echo $this->PHP;

				return $this->PHP;

			}

		}else if(isset($options['php'])&&!is_null($options['php'])){

			echo $options['php'];

			return $options['php'];

		}

		$res=Array();

		if($options['openphp'])

			$res[]="<?php";

		$res[]="/**";

		if(!is_null($this->Docs)){

			$res[]=" * ".implode("\n * ",explode("\n",$this->Docs));

			$res[]=" *";

		}

		$res[]=" * @service ".$options['class'];

		$res[]=" */";

		$res[]="class ".$options['class']."{";

		$res[]="\t/**";

		$res[]="\t * The WSDL URI";

		$res[]="\t *";

		$res[]="\t * @var string";

		$res[]="\t */";

		$res[]="\tpublic static \$_WsdlUri='".(!is_null($this->WsdlUri)?$this->WsdlUri:$this->EndPoint.'?WSDL')."';";

		$res[]="\t/**";

		$res[]="\t * The PHP SoapClient object";

		$res[]="\t *";

		$res[]="\t * @var object";

		$res[]="\t */";

		$res[]="\tpublic static \$_Server=null;";

		self::CallHook('BeginCreatePhpHook',$data);

		$res[]='';

		$res[]="\t/**";

		$res[]="\t * Send a SOAP request to the server";

		$res[]="\t *";

		$res[]="\t * @param string \$method The method name";

		$res[]="\t * @param array \$param The parameters";

		$res[]="\t * @return mixed The server response";

		$res[]="\t */";

		$res[]="\tpublic static function _Call(\$method,\$param){";

		if(self::CallHook('CreatePhpCallHook',$data)){

			$res[]="\t\tif(is_null(self::\$_Server))";

			if($options['phpclient']){

				$res[]="\t\t\tself::\$_Server=new SoapClient(self::\$_WsdlUri);";

				$res[]="\t\treturn self::\$_Server->__soapCall(\$method,\$param);";

			}else{

				$res[]="\t\t\tself::\$_Server=new PhpWsdlClient(self::\$_WsdlUri);";

				$res[]="\t\treturn self::\$_Server->DoRequest(\$method,\$param);";

			}

		}

		$res[]="\t}";

		// Methods

		$i=-1;

		$len=sizeof($this->Methods);

		while(++$i<$len){

			$res[]='';

			$this->Methods[$i]->CreateMethodPhp($data);

		}

		$res[]="}";

		// Types

		$i=-1;

		$len=sizeof($this->Types);

		while(++$i<$len){

			$res[]='';

			$this->Types[$i]->CreateTypePhp($data);

		}

		self::CallHook('EndCreatePhpHook',$data);

		$res=utf8_encode(implode("\n",$res));

		if(!$hasOptions){

			if(is_null($this->PHP))

				$this->PHP=$res;

			if($cache)

				$this->WriteWsdlToCache(null,null,null,true);

		}

		if($echo)

			echo $res;

		return $res;

	}

	

	/**

	 * Output the PHP SOAP client source for this webservice, if requested

	 * 

	 * @param boolean $andExit Exit after sending the PHP source?

	 * @return boolean PHP sent?

	 */

	public function OutputPhpOnRequest($andExit=true){

		if(!$this->IsPhpRequested())

			return false;

		$this->OutputPhp();

		if($andExit){

			self::Debug('Exit script execution');

			exit;

		}

		return true;

	}

	

	/**

	 * Run the PHP SoapServer

	 * 

	 * @param string $wsdlFile The WSDL file name or NULL to let PhpWsdl decide (default: NULL)

	 * @param string|object|array $class The class name to serve, the classname and class as array or NULL (default: NULL)

	 * @param boolean $andExit Exit after running the server? (default: TRUE)

	 * @param boolean $forceNoWsdl Force no WSDL usage? (default: FALSE);

	 * @return boolean Did the server run?

	 */

	public function RunServer($wsdlFile=null,$class=null,$andExit=true,$forceNoWsdl=false){

		self::Debug('Run the server');

		if($forceNoWsdl)

			self::Debug('Forced non-WSDL mode');

		if(self::CallHook(

				'BeforeRunServerHook',

				Array(

					'server'		=>	$this,

					'wsdlfile'		=>	&$wsdlFile,

					'class'			=>	&$class,

					'andexit'		=>	&$andExit,

					'forcenowsdl'	=>	&$forceNoWsdl

				)

			)

		){

			// WSDL requested?

			if($this->OutputWsdlOnRequest($andExit))

				return false;

			// PHP requested?

			if($this->OutputPhpOnRequest($andExit))

				return false;

			// HTML requested?

			if($this->OutputHtmlOnRequest($andExit))

				return false;

		}

		// Login

		$user=null;

		$password=null;

		if($this->RequireLogin){

			if(isset($_SERVER['PHP_AUTH_USER'])||isset($_SERVER['PHP_AUTH_PW'])){

				$user=(isset($_SERVER['PHP_AUTH_USER']))?$_SERVER['PHP_AUTH_USER']:null;

				$password=(isset($_SERVER['PHP_AUTH_PW']))?$_SERVER['PHP_AUTH_PW']:null;

			}

			self::Debug('Check login '.$user.':'.str_repeat('*',strlen($password)));

			if(!self::CallHook(

					'LoginHook',

					Array(

						'server'		=>	$this,

						'user'			=>	&$user,

						'password'		=>	&$password

					)

				)

			){

				self::Debug('Login required');

				header('WWW-Authenticate: Basic realm="Webservice login required"');

			    header('HTTP/1.0 401 Unauthorized');

				if($andExit){

					self::Debug('Exit script execution');

					exit;

				}

			    return false;

			}

		}

		// Load the proxy

		$useProxy=false;

		if(is_array($class)){

			self::Debug('Use the proxy for '.$class[0]);

			self::$ProxyObject=$class[1];

			self::$ProxyServer=$this;

			$class=$class[0];

			$useProxy=true;

		}

		// Ensure a webservice name

		if(is_null($class)){

			self::Debug('No webservice name yet');

			if(!$this->DetermineConfiguration())

				throw(new Exception('Invalid configuration'));

			if(!is_null($this->Name))

				$class=$this->Name;

		}else if(is_string($class)){

			self::Debug('Using '.$class.' as webservice name');

			$this->Name=$class;

		}

		self::Debug('Use class '.((!is_object($class))?$class:get_class($class)));

		// Load WSDL

		if(!$forceNoWsdl&&(!$useProxy||self::$UseProxyWsdl)){

			self::Debug('Load WSDL');

			$this->CreateWsdl(false,true);

			if(is_null($wsdlFile))

				$wsdlFile=$this->GetCacheFileName();

			if(!is_null($wsdlFile))

				if(!file_exists($wsdlFile)){

					self::Debug('WSDL file "'.$wsdlFile.'" does not exists');

					$wsdlFile=null;

				}

		}

		// Load the files, if the webservice handler class doesn't exist

		if(!is_object($class))

			if(!class_exists($class)&&!$this->IsOnlyGlobal()){

				self::Debug('Try to load the webservice handler class');

				$i=-1;

				$len=sizeof($this->Files);

				while(++$i<$len){

					self::Debug('Load '.$this->Files[$i]);

					require_once($this->Files[$i]);

				}

				if(!class_exists($class)){

					// Try class.webservice.php

					if(file_exists('class.webservice.php')){

						self::Debug('Try to load class.webservice.php');

						require_once('class.webservice.php');

						if(class_exists($class))

							$this->Files[]='class.webservice.php';

					}

					if(!class_exists($class))

						if(file_exists(dirname(__FILE__).'/class.webservice.php')){

							self::Debug('Try to load '.dirname(__FILE__).'/class.webservice.php');

							require_once(dirname(__FILE__).'/class.webservice.php');

							if(class_exists($class))

								$this->Files[]=dirname(__FILE__).'/class.webservice.php';

						}

					if(!class_exists($class))

						// A handler class or object is required when using non-global methods!

						throw(new Exception('Webservice handler class not present'));

				}

			}

		// Prepare the PhpWsdlHandler

		if($this->CreateHandler){

			self::Debug('Use PhpWsdlHandler');

			if(is_null($class))

				$class=$this->Name;

			$class=$this->CreateHandler($class);

		}

		// Prepare the SOAP server

		$this->SoapServer=null;

		if(self::CallHook(

				'PrepareServerHook',

				Array(

					'server'		=>	$this,

					'soapserver'	=>	&$this->SoapServer,

					'wsdlfile'		=>	&$wsdlFile,

					'class'			=>	&$class,

					'useproxy'		=>	&$useProxy,

					'forcenowsdl'	=>	&$forceNoWsdl,

					'andexit'		=>	&$andExit,

					'user'			=>	&$user,

					'password'		=>	&$password

				)

			)

		){

			self::Debug('Prepare the SOAP server');

			// WSDL file

			$wsdlFile=($forceNoWsdl||($useProxy&&!self::$UseProxyWsdl))?null:$wsdlFile;

			if(!is_null($wsdlFile)){

				self::Debug('Using WSDL file '.$wsdlFile);

			}else{

				self::Debug('No WSDL file');

			}

			// Server options

			$temp=Array(

				'actor'			=>	$this->EndPoint,

				'uri'			=>	$this->NameSpace,

			);

			$temp=array_merge($this->SoapServerOptions,$temp);

			if(self::$Debugging)

				self::Debug('Server options: '.print_r($temp,true));

			// Create the server object

			self::Debug('Creating PHP SoapServer object');

			$this->SoapServer=new SoapServer(

				$wsdlFile,

				$temp

			);

			// Set the handler class or object

			if($useProxy||!is_object($class)){

				$temp=($useProxy)?'PhpWsdlProxy':$class;

				if(!is_null($temp)){

					self::Debug('Setting server class '.$temp);

					$this->SoapServer->setClass($temp);

				}else{

					self::Debug('No server class or object');

				}

			}else{

				self::Debug('Setting server object '.get_class($class));

				$this->SoapServer->setObject($class);

			}

			// Add global methods

			if(!$useProxy&&!$this->CreateHandler){

				$i=-1;

				$len=sizeof($this->Methods);

				while(++$i<$len)

					if($this->Methods[$i]->IsGlobal){

						self::Debug('Adding global method '.$this->Methods[$i]->Name);

						$this->SoapServer->addFunction($this->Methods[$i]->Name);

					}

			}else{

				self::Debug('Omit adding global methods to the SoapServer object since they will be called by the proxy or the PhpWsdlHandler object');

			}

		}

		// Run the SOAP server

		if(self::CallHook(

				'RunServerHook',

				Array(

					'server'		=>	$this,

					'soapserver'	=>	&$this->SoapServer,

					'wsdlfile'		=>	&$wsdlFile,

					'class'			=>	&$class,

					'useproxy'		=>	&$useProxy,

					'forcenowsdl'	=>	&$forceNoWsdl,

					'andexit'		=>	&$andExit,

					'user'			=>	&$user,

					'password'		=>	&$password

				)

			)

		){

			self::Debug('Run the SOAP server');

			$this->SoapServer->handle();

			if($andExit){

				self::Debug('Exit script execution');

				exit;

			}

		}

		return true;

	}

	

	/**

	 * Get the WSDL download URI

	 * 

	 * @return string The Uri

	 */

	public function GetWsdlUri(){

		return ((is_null($this->WsdlUri))?$this->EndPoint:$this->WsdlUri).'?WSDL';

	}

	

	/**

	 * Get the PHP download URI

	 * 

	 * @return string The URI

	 */

	public function GetPhpUri(){

		return ((is_null($this->PhpUri))?$this->EndPoint:$this->PhpUri).'?PHPSOAPCLIENT';

	}

	

	/**

	 * Get the HTML documentation URI

	 * 

	 * @return string The Uri

	 */

	public function GetDocUri(){

		return (is_null($this->PhpUri))?$this->EndPoint:$this->DocUri;

	}

	

	/**

	 * Find a method

	 * 

	 * @param string $name The method name

	 * @return PhpWsdlMethod The method object or NULL

	 */

	public function GetMethod($name){

		self::Debug('Find method '.$name);

		$i=-1;

		$len=sizeof($this->Methods);

		while(++$i<$len)

			if($this->Methods[$i]->Name==$name){

				self::Debug('Found method at index '.$i);

				return $this->Methods[$i];

			}

		return null;

	}

	

	/**

	 * Find a complex type

	 * 

	 * @param string $name The type name

	 * @return PhpWsdlComplex The type object or NULL

	 */

	public function GetType($name){

		self::Debug('Find type '.$name);

		$i=-1;

		$len=sizeof($this->Types);

		while(++$i<$len)

			if($this->Types[$i]->Name==$name){

				self::Debug('Found type at index '.$i);

				return $this->Types[$i];

			}

		return null;

	}

	

	/**

	 * Set a object for all methods from a class

	 * 

	 * @param string $class The class name

	 * @param object $obj An instance of the class

	 */

	public function SetMethodObject($class,$obj){

		$i=-1;

		$len=sizeof($this->Methods);

		while(++$i<$len){

			$m=$this->Methods[$i];

			if($m->Class!=$class)

				continue;

			$m->Class=$obj;

		}

	}

	

	/**

	 * Get the cache filename

	 * 

	 * @param string $endpoint The endpoint URI or NULL to use the PhpWsdl->EndPoint property (default: NULL)

	 * @return string The cache filename or NULL, if caching is disabled

	 */

	public function GetCacheFileName($endpoint=null){

		$data=Array(

			'server'		=>	$this,

			'endpoint'		=>	$endpoint,

			'filename'		=>	(is_null(self::$CacheFolder))?null:self::$CacheFolder.'/'.sha1((is_null($endpoint))?$this->EndPoint:$endpoint).'.wsdl'

		);

		self::CallHook(

			'CacheFileNameHook',

			$data

		);

		return $data['filename'];

	}



	/**

	 * Determine if the cache file exists

	 * 

	 * @param string $file The WSDL cache filename or NULL to use the default (default: NULL)

	 * @return boolean Are the cache files present?

	 */

	public function CacheFileExists($file=null){

		if(is_null($file))

			$file=$this->GetCacheFileName();

		self::Debug('Check cache file exists '.$file);

		return file_exists($file)&&file_exists($file.'.cache');

	}

	

	/**

	 * Determine if the existing cache files are still valid

	 * 

	 * @param string $file The WSDL cache filename or NULL to use the default (default: NULL)

	 * @return boolean Valid?

	 */

	public function IsCacheValid($file=null){

		self::Debug('Check cache valid');

		if(is_null($file))

			$file=$this->GetCacheFileName();

		if(!$this->CacheFileExists($file))

			return false;

		return self::$CacheTime<0||time()-file_get_contents($file.'.cache')<=self::$CacheTime;

	}

	

	/**

	 * Get the WSDL from the cache

	 * 

	 * @param string $file The WSDL cache filename or NULL to use the default (default: NULL)

	 * @param boolean $force Force this even if the cache is timed out? (default: FALSE)

	 * @param boolean $nounserialize Don't unserialize the PhpWsdl* objects? (default: FALSE)

	 * @return string The cached WSDL

	 */

	public function GetWsdlFromCache($file=null,$force=false,$nounserialize=false){

		self::Debug('Get WSDL from cache');

		if(!is_null($this->WSDL))

			return $this->WSDL;

		if(is_null($file))

			$file=$this->GetCacheFileName();

		if(!$force){

			if(!$this->IsCacheValid($file))

				return null;

		}else if(!$this->CacheFileExists($file)){

			return null;

		}

		$this->WSDL=file_get_contents($file);

		if(!$nounserialize){

			self::Debug('Unserialize methods, types and files');

			$data=unserialize(file_get_contents($file.'.obj'));

			$this->Methods=$data['methods'];

			$this->Types=$data['types'];

			$this->Files=$data['files'];

			$this->Name=$data['name'];

			$this->Docs=$data['docs'];

			$this->HTML=$data['html'];

			$this->PHP=$data['php'];

			$this->WsdlUri=$data['wsdluri'];

			$this->PhpUri=$data['phpuri'];

			$this->DocUri=$data['docuri'];

			$this->HandlerPhp=$data['handler'];

			self::CallHook(

				'ReadCacheHook',

				Array(

					'server'		=>	$this,

					'data'			=>	&$data

				)

			);

			if($data['version']!=self::$VERSION){

				self::Debug('Could not use cache from version '.$data['version']);

				$this->Methods=Array();

				$this->Types=Array();

				$this->Files=Array();

				$this->Name=null;

				$this->Docs=null;

				$this->HTML=null;

				$this->PHP=null;

				$this->WsdlUri=null;

				$this->PhpUri=null;

				$this->DocUri=null;

				$this->WSDL=null;

				$this->TidyCacheFolder(true);

				return null;

			}

		}

		$this->ConfigurationDetermined=true;

		$this->SourcesParsed=true;

		return $this->WSDL;

	}

	

	/**

	 * Write WSDL to cache

	 * 

	 * @param string $wsdl The UTF-8 encoded WSDL string (default: NULL)

	 * @param string $endpoint The SOAP endpoint or NULL to use the default (default: NULL)

	 * @param string $file The target filename or NULL to use the default (default: NULL)

	 * @param boolean $force Force refresh (default: FALSE)

	 * @return boolean Succeed?

	 */

	public function WriteWsdlToCache($wsdl=null,$endpoint=null,$file=null,$force=false){

		self::Debug('Write WSDL to the cache');

		if(is_null($endpoint))

			$endpoint=$this->EndPoint;

		if($endpoint==$this->EndPoint&&!is_null($wsdl))

			$this->WSDL=$wsdl;

		if(is_null($wsdl)){

			if(is_null($this->WSDL)){

				self::Debug('No WSDL');

				return false;// WSDL not defined

			}

			$wsdl=$this->WSDL;

		}

		if(is_null($file)){

			$file=$this->GetCacheFileName($endpoint);

			if(is_null($file)){

				self::Debug('No cache file');

				return false;// No cache file

			}

		}

		$temp=substr($file,0,1);

		if($temp!='/'&&$temp!='.'){

			if(is_null(self::$CacheFolder)){

				self::Debug('No cache folder');

				return false;// No cache folder

			}

			$file=self::$CacheFolder.'/'.$file;

		}

		if(!$force)

			if($this->IsCacheValid($file)){

				self::Debug('Cache is still valid');

				return true;// Existing cache is still valid

			}

		self::Debug('Write to '.$file);

		if(file_put_contents($file,$wsdl)===false){

			self::Debug('Could not write to cache');

			return false;// Error writing to cache

		}

		if(file_put_contents($file.'.cache',time())===false){

			self::Debug('Could not write cache time file');

			return false;// Error writing to cache

		}

		$data=Array(

			'version'		=>	self::$VERSION,

			'methods'		=>	$this->Methods,

			'types'			=>	$this->Types,

			'files'			=>	$this->Files,

			'name'			=>	$this->Name,

			'docs'			=>	$this->Docs,

			'html'			=>	$this->HTML,

			'php'			=>	$this->PHP,

			'wsdluri'		=>	$this->WsdlUri,

			'phpuri'		=>	$this->PhpUri,

			'docuri'		=>	$this->DocUri,

			'handler'		=>	($this->CreateHandler)?$this->HandlerPhp:null

		);

		self::CallHook(

			'WriteCacheHook',

			Array(

				'server'		=>	$this,

				'data'			=>	&$data

			)

		);

		if(file_put_contents($file.'.obj',serialize($data))===false){

			self::Debug('Could not write serialized cache');

			return false;// Error writing to cache

		}

		return true;

	}

	

	/**

	 * Determine if the cache folder is writeable

	 * 

	 * @param string $folder The folder or NULL to use the static property CacheFolder (default: NULL)

	 * @return boolean Writeable?

	 */

	public static function IsCacheFolderWriteAble($folder=null){

		if(!is_null(self::$CacheFolderWriteAble))

			return self::$CacheFolderWriteAble;

		if(is_null($folder))

			$folder=self::$CacheFolder;

		if(is_null($folder)){

			self::$CacheFolderWriteAble=false;

			return false;

		}

		if(!is_dir($folder)){

			self::Debug('Invalid cache folder (not a directory?)');

			self::$CacheFolderWriteAble=false;

			return;

		}

		$file=uniqid();

		while(file_exists($folder.'/'.$file))

			$file=uniqid();

		$file=$folder.'/'.$file;

		$temp=uniqid();

		if(file_put_contents($file,$temp)===false){

			self::$CacheFolderWriteAble=false;

			return false;

		}

		$res=file_get_contents($file)===$temp;

		unlink($file);

		self::$CacheFolderWriteAble=$res;

		return $res;

	}

	

	/**

	 * Determine if the cache is different from the current version of your webservice handler class.

	 * Status: Untested

	 * 

	 * @return boolean Differences detected?

	 */

	public function IsCacheDifferent(){

		self::Debug('Determine if the cache is different from this instance');

		// Load the cache

		$temp=new PhpWsdl(null,$this->EndPoint);

		$temp->GetWsdlFromCache();

		if(is_null($temp->WSDL))

			return true;// Not cached yet

		// Initialize this instance

		$this->DetermineConfiguration();

		$this->ParseSource();

		// Compare the cache with this instance

		$res=serialize(

				Array(

					$this->Methods,

					$this->Types

				)

			)!=serialize(

				Array(

					$temp->Methods,

					$temp->Types

				)

			);

		self::Debug('Cache is '.(($res)?'equal':'different'));

		return $res;

	}

	

	/**

	 * Delete cache files from the cache folder

	 * 

	 * @param boolean $mineOnly Only delete the cache files for this definition? (default: FALSE)

	 * @param boolean $cleanUp Only delete the cache files that are timed out? (default: FALSE)

	 * @param string $wsdlFile The WSDL filename (default: NULL)

	 * @return string[] The deleted filenames

	 */

	public function TidyCacheFolder($mineOnly=false,$cleanUp=false,$wsdlFile=null){

		if(is_null(self::$CacheFolder))

			return Array();

		$deleted=Array();

		if($cleanUp){

			self::Debug('Cleanup cache');

		}else if($mineOnly){

			self::Debug('Clean own cache');

		}else{

			self::Debug('Clean all cache');

		}

		if($mineOnly){

			self::Debug('Delete own cache');

			$file=(is_null($wsdlFile))?$this->GetCacheFileName():$wsdlFile;

			if($cleanUp)

				if($this->IsCacheValid($file))

					return $deleted;

			if(file_exists($file))

				if(unlink($file))

					$deleted[]=$file;

			if(file_exists($file.'.cache'))

				if(unlink($file.'.cache'))

					$deleted[]=$file.'.cache';

			if(file_exists($file.'.obj'))

				if(unlink($file.'.obj'))

					$deleted[]=$file.'.obj';

			self::Debug(sizeof($deleted).' files deleted');

		}else{

			self::Debug('Delete whole cache');

			$files=glob(self::$CacheFolder.(($cleanUp)?'/*.wsdl':'/*.wsd*'));

			if($files!==false){

				$toDelete=Array();

				$i=-1;

				$len=sizeof($files);

				while(++$i<$len){

					$file=$files[$i];

					if($cleanUp){

						if(!$this->IsCacheValid($file))

							continue;

						$toDelete[]=$file;

						$toDelete[]=$file.'.cache';

						$toDelete[]=$file.'.obj';

					}else{

						if(!preg_match('/\.wsdl(\.cache|\.obj)?$/',$file))

							continue;

						if(unlink($files[$i]))

							$deleted[]=$files[$i];

					}

				}

				if($cleanUp){

					$i=-1;

					$len=sizeof($toDelete);

					while(++$i<$len)

						if(file_exists($toDelete[$i]))

							if(unlink($toDelete[$i]))

								$deleted[]=$toDelete[$i];

				}

				self::Debug(sizeof($deleted).' files deleted');

			}else{

				self::Debug('"glob" failed');

			}

		}

		return $deleted;

	}

	

	/**

	 * Create the handler object for this webservice

	 * 

	 * @param string|object $targetHandler The target handler class name or object or NULL

	 * @return PhpWsdlHandler The handler object

	 */

	public function CreateHandler($targetHandler=null){

		if(!is_null($this->Handler))

			return $this->Handler;

		self::Debug('Create the handler object');

		if(class_exists('PhpWsdlHandler')){

			self::Debug('PhpWsdlHandler exists');

			$this->Handler=new PhpWsdlHandler($this,$targetHandler);

			self::Debug('Handler object created');

			return $this->Handler;

		}

		self::Debug('Create PhpWsdlHandler');

		if(is_null($this->HandlerPhp)){

			$php=Array();

			$php[]='class PhpWsdlHandler{';

			// Variables

			$php[]='public $_Server=null;';

			$php[]='public $_TargetHandler=null;';

			// Constructor

			$php[]='public function PhpWsdlHandler($server,$targetHandler){';

			$php[]='$this->_Server=$server;';

			$php[]='$this->_TargetHandler=$targetHandler;';

			$php[]='}';

			// Caller method

			$php[]='public function _Call($method,$param){';

			$php[]='$obj=null;';

			$php[]='$m=$this->_Server->GetMethod($method);';

			$php[]='if(!$m->IsGlobal) $obj=(is_null($m->Class))?$this->_TargetHandler:$m->Class;';

			$php[]='$call=(is_null($obj))?$m->Name:Array($obj,$m->Name);';

			$php[]='return call_user_func_array($call,$param);';

			$php[]='}';

			// Webservice methods

			$i=-1;

			$len=sizeof($this->Methods);

			while(++$i<$len){

				$m=$this->Methods[$i];

				$temp=Array();

				$j=-1;

				$pLen=sizeof($m->Param);

				while(++$j<$pLen)

					$temp[]='$'.$m->Param[$j]->Name;

				$temp=implode(',',$temp);

				$php[]='public function '.$m->Name.'('.$temp.'){';

				$php[]='return $this->_Call("'.$m->Name.'",Array('.$temp.'));';

				$php[]='}';

			}

			$php[]='}';

			$php=implode("\n",$php);

			$this->HandlerPhp=$php;

			$this->WriteWsdlToCache(null,null,null,true);

		}else{

			$php=$this->HandlerPhp;

		}

		eval($php);

		$this->Handler=new PhpWsdlHandler($this,$targetHandler);

		self::Debug('Handler object created');

		return $this->Handler;

	}

	

	/**

	 * Translate a type name for WSDL

	 * 

	 * @param string $type The type name

	 * @return string The translated type name

	 */

	public static function TranslateType($type){

		if(!self::CallHook(

				'TranslateTypeHook',

				Array(

					'type'			=>	&$type

				)

			)

		)

			return $type;

		return ((in_array($type,self::$BasicTypes))?self::$Config['xsd']:self::$Config['tns']).':'.$type;

	}

	

	/**

	 * Translate a target type name for WSDL

	 * 

	 * @param string $type The type name

	 * @return string The translated target type name

	 */

	public function TranslateTargetType($type){

		if(!self::CallHook(

				'TranslateTargetTypeHook',

				Array(

					'type'			=>	&$type

				)

			)

		)

			return $type;

		if(in_array($type,self::$BasicTypes))

			return self::TranslateType($type);

		$t=$this->GetType($type);

		if(is_null($t))

			return self::TranslateType($type);

		switch(get_class($t)){

			case 'PhpWsdlEnum':

				return self::TranslateType($t->Type);

				break;

			default:

				return self::TranslateType($type);

				break;

		}

	}

	

	/**

	 * Call a hook function

	 * 

	 * @param string $name The hook name

	 * @param mixed $data The parameter (default: NULL)

	 * @return boolean Response

	 */

	public static function CallHook($name,$data=null){

		self::Debug('Call hook '.$name);

		if(!self::HasHookHandler($name))

			return true;

		$keys=array_keys(self::$Config['extensions'][$name]);

		$i=-1;

		$len=sizeof($keys);

		while(++$i<$len){

			$fnc=self::$Config['extensions'][$name][$keys[$i]];

			self::Debug('Call '.$fnc);

			if(is_string($fnc)&&strpos($fnc,'::')>-1) $fnc=explode('::',$fnc);

			if(!call_user_func($fnc,$data)){

				self::Debug('Handler stopped hook execution');

				return false;

			}

		}

		return true;

	}

	

	/**

	 * Register a hook

	 * 

	 * @param string $hook The hook name

	 * @param string $name The call name

	 * @param mixed $data The hook call data

	 */

	public static function RegisterHook($hook,$name,$data){

		if(!self::HasHookHandler($hook))

			self::$Config['extensions'][$hook]=Array();

		if(self::$Debugging){

			$handler=$data;

			if(is_array($handler)){

				$class=$handler[0];

				$method=$handler[1];

				if(is_object($class))

					$class=get_class($class);

				$handler=$class.'.'.$method;

			}

			self::Debug('Register hook '.$hook.' handler '.$name.': '.$handler);

		}

		self::$Config['extensions'][$hook][$name]=$data;

	}

	

	/**

	 * Unregister a hook

	 * 

	 * @param string $hook The hook name

	 * @param string $name The call name or NULL to unregister the whole hook

	 */

	public static function UnregisterHook($hook,$name=null){

		if(!self::HasHookHandler($hook))

			return;

		if(!is_null($name)){

			if(!isset(self::$Config['extensions'][$hook][$name]))

				return;

		}else{

			unset(self::$Config['extensions'][$hook]);

			return;

		}

		unset(self::$Config['extensions'][$hook][$name]);

		if(self::$Debugging)

			self::Debug('Unregister hook '.$hook.' handler '.$name);

		if(sizeof(self::$Config['extensions'][$hook])<1)

			unset(self::$Config['extensions'][$hook]);

	}

	

	/**

	 * Determine if a hook has a registered handler

	 * 

	 * @param string $hook The hook name

	 * @return boolean Has handler?

	 */

	public static function HasHookHandler($hook){

		return isset(self::$Config['extensions'][$hook]);

	}

	

	/**

	 * Get the encoding data for a type

	 * 

	 * @param string $type The type name

	 * @param boolean $parameter Get the parameter definition? (default: FALSE)

	 * @param boolean $defaults Fall back to defaults? (default: TRUE)

	 * @param PhpWsdl $server The PhpWsdl object (default: NULL)

	 * @return array The encoding data or NULL, if not found

	 */

	public static function GetEncoding($type,$parameter=false,$defaults=true,$server=null){

		if($parameter){

			if(isset(self::$TypeEncoding['parameter'][$type]))

				return self::$TypeEncoding['parameter'][$type];

		}else{

			if(isset(self::$TypeEncoding['return'][$type]))

				return self::$TypeEncoding['return'][$type];

		}

		if(!in_array($type,self::$BasicTypes)){

			$t=null;

			if(!is_null($server))

				$t=$server->GetType($type);

			return Array(

					'encoding'		=>	(is_null($t)||!$t->IsArray)?SOAP_ENC_OBJECT:SOAP_ENC_ARRAY

				);

		}

		if(!$defaults)

			return null;

		return (isset(self::$TypeEncoding['default'][$type]))

			?self::$TypeEncoding['default'][$type]

			:null;

	}

	

	/**

	 * Set the SOAP encoding for a type

	 * 

	 * @param string $type The type name

	 * @param string|int $encoding The SOAP encoding

	 * @param boolean $parameter Set the parameter definition? (default: FALSE)

	 */

	public static function SetEncoding($type,$encoding,$parameter=false){

		self::$TypeEncoding[($parameter)?'parameter':'return'][$type]=Array(

				'encoding'		=>	$encoding

			);

	}

	

	/**

	 * Encode some data for SOAP

	 * 

	 * @param string $type The type name

	 * @param mixed $data The data to be encoded

	 * @param boolean $parameter Get the parameter definition? (default: FALSE)

	 * @param PhpWsdl $server The PhpWsdl object (default: NULL)

	 * @return mixed|SoapVar The SoapVar object

	 */

	public static function DoEncoding($type,$data,$parameter=false,$server=null){

		$res=null;

		if(!self::CallHook(

				'EncodeHook',

				Array(

					'server'		=>	&$server,

					'type'			=>	&$type,

					'data'			=>	&$data,

					'parameter'		=>	&$parameter,

					'res'			=>	&$res

				)

			)

		)

			return $res;

		if(!self::CallHook(

				'Encode'.$type.'Hook',

				Array(

					'server'		=>	&$server,

					'type'			=>	&$type,

					'data'			=>	&$data,

					'parameter'		=>	&$parameter,

					'res'			=>	&$res

				)

			)

		)

			return $res;

		$t=null;

		if(!is_null($server)&&!in_array($type,self::$BasicTypes)){

			$t=$server->GetType($type);

			if(get_class($t)=='PhpWsdlEnum')

				if(!in_array($t->Type,self::$BasicTypes)){

					$t=$server->GetType($t->Type);

				}else{

					$type=$t->Type;

					$t=null;

				}

		}

		$enc=self::GetEncoding($type,$parameter,true,$server);

		if(is_null($enc))

			$enc=Array(

					'encoding'		=>	(is_null($t)||!$t->IsArray)?SOAP_ENC_OBJECT:SOAP_ENC_ARRAY

				);

		if(!is_null($server))

			$enc['ns']=$server->NameSpace;

		if(isset($enc['ns']))

			return new SoapVar($data,$enc['encoding'],$type,$enc['ns']);

		return new SoapVar($data,$enc['encoding']);

	}

	

	/**

	 * Add a debugging message

	 * 

	 * @param string $str The message to add to the debug protocol

	 */

	public static function Debug($str){

		if(!self::$Debugging)

			return;

		if(!is_null(self::$DebugHandler)){

			call_user_func(self::$DebugHandler,$str);

			return;

		}

		$temp=date('Y-m-d H:i:s')."\t".$str;

		if(self::$DebugBackTrace){

			$trace=debug_backtrace();

			$temp.=" ('".$trace[1]['function']."' in '".basename($trace[1]['file'])."' at line #".$trace[1]['line'].")";

		}

		self::$DebugInfo[]=$temp;

		if(!is_null(self::$DebugFile))

			if(file_put_contents(self::$DebugFile,$temp."\n",FILE_APPEND)===false){

				$temp=self::$DebugFile;

				self::$DebugFile=null;

				self::Debug('Could not write to debug file "'.$temp.'"');

			}

	}



	/**

	 * Initialize PhpWsdl

	 */

	public static function Init(){

		self::Debug('Init');

		// Configuration

		self::$HTML2PDFSettings=Array(

			'attachments'	=>	'1',

			'outline'		=>	'1'

		);

		self::$NameSpaces=Array(

			'soap'			=>	'http://schemas.xmlsoap.org/wsdl/soap/',

			's'				=>	'http://www.w3.org/2001/XMLSchema',

			'wsdl'			=>	'http://schemas.xmlsoap.org/wsdl/',

			'soapenc'		=>	'http://schemas.xmlsoap.org/soap/encoding/'

		);

		//TODO How to encode the missing basic types?

		self::$TypeEncoding=Array(

			'parameter'		=>	Array(),

			'return'		=>	Array(),

			'default'		=>	Array(

				'string'		=>	Array(

						'encoding'		=>	XSD_STRING

					),

				'boolean'		=>	Array(

						'encoding'		=>	XSD_BOOLEAN

					),

				'decimal'		=>	Array(

						'encoding'		=>	XSD_DECIMAL

					),

				'float'			=>	Array(

						'encoding'		=>	XSD_FLOAT

					),

				'double'		=>	Array(

						'encoding'		=>	XSD_DOUBLE

					),

				'duration'		=>	Array(

						'encoding'		=>	XSD_DURATION

					),

				'dateTime'		=>	Array(

						'encoding'		=>	XSD_DATETIME

					),

				'time'			=>	Array(

						'encoding'		=>	XSD_TIME

					),

				'date'			=>	Array(

						'encoding'		=>	XSD_DATE

					),

				'gYearMonth'	=>	Array(

						'encoding'		=>	XSD_GYEARMONTH

					),

				'gYear'			=>	Array(

						'encoding'		=>	XSD_GYEAR

					),

				'gMonthDay'		=>	Array(

						'encoding'		=>	XSD_GMONTHDAY

					),

				'gDay'			=>	Array(

						'encoding'		=>	XSD_GDAY

					),

				'gMonth'		=>	Array(

						'encoding'		=>	XSD_GMONTH

					),

				'hexBinary'		=>	Array(

						'encoding'		=>	XSD_HEXBINARY

					),

				'base64Binary'	=>	Array(

						'encoding'		=>	XSD_BASE64BINARY

					),

				'anyURI'		=>	Array(

						'encoding'		=>	XSD_ANYURI

					),

				'QName'			=>	Array(

						'encoding'		=>	XSD_QNAME

					),

				'NOTATION'		=>	Array(

						'encoding'		=>	XSD_NOTATION

					),

				'int'			=>	Array(

						'encoding'		=>	XSD_INT

					),

				'integer'		=>	Array(

						'encoding'		=>	XSD_INTEGER

					),

				'long'			=>	Array(

						'encoding'		=>	XSD_LONG

					),

				'short'			=>	Array(

						'encoding'		=>	XSD_SHORT

					),

				'byte'			=>	Array(

						'encoding'		=>	XSD_BYTE

					),

				'anyType'		=>	Array(

						'encoding'		=>	XSD_ANYTYPE

					)

			)

		);

		self::EnableCache();

		self::$Config['extensions']=Array();// A configuration space for extensions

		self::$Config['tns']='tns';			// The xmlns name for the target namespace

		self::$Config['xsd']='s';			// The xmlns name for the XSD namespace

		// Parser hooks

		self::RegisterHook('InterpretKeywordserviceHook','internal','PhpWsdl::InterpretService');

		self::RegisterHook('InterpretKeywordpw_setHook','internal','PhpWsdl::InterpretSetting');

		// WSDL hooks

		self::RegisterHook('CreateWsdlHeaderHook','internal','PhpWsdl::CreateWsdlHeader');

		self::RegisterHook('CreateWsdlTypeSchemaHook','internal','PhpWsdl::CreateWsdlTypeSchema');

		self::RegisterHook('CreateWsdlMessagesHook','internal','PhpWsdl::CreateWsdlMessages');

		self::RegisterHook('CreateWsdlPortsHook','internal','PhpWsdl::CreateWsdlPorts');

		self::RegisterHook('CreateWsdlBindingsHook','internal','PhpWsdl::CreateWsdlBindings');

		self::RegisterHook('CreateWsdlServiceHook','internal','PhpWsdl::CreateWsdlService');

		self::RegisterHook('CreateWsdlFooterHook','internal','PhpWsdl::CreateWsdlFooter');

		self::RegisterHook('CreateWsdlOptimizeHook','internal','PhpWsdl::CreateWsdlOptimize');

		// HTML hooks

		self::RegisterHook('CreateHtmlGeneralHook','internal','PhpWsdl::CreateHtmlGeneral');

		self::RegisterHook('CreateHtmlIndexHook','internal','PhpWsdl::CreateHtmlIndex');

		self::RegisterHook('CreateHtmlMethodsHook','internal','PhpWsdl::CreateHtmlMethods');

		self::RegisterHook('CreateHtmlComplexTypesHook','internal','PhpWsdl::CreateHtmlComplexTypes');

		// Extensions

		self::Debug('Load extensions');

		$files=glob(dirname(__FILE__).'/'.'class.phpwsdl.*.php');

		if($files!==false){

			$i=-1;

			$len=sizeof($files);

			while(++$i<$len){

				self::Debug('Load '.$files[$i]);

				require_once($files[$i]);

			}

		}else{

			self::Debug('"glob" failed');

		}

	}



	/**

	 * Do things after the environment is configured

	 */

	public static function PostInit(){

		self::CallHook('PostInitHook');

		// Autorun

		global $PhpWsdlAutoRun;

		if(self::$AutoRun||$PhpWsdlAutoRun)

			self::RunQuickMode();

	}

}