<?php
//=============================================================================
//
// Copyright Francois Laupretre <automap@tekwire.net>
//
//   Licensed 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.
//
//=============================================================================
/**
* @copyright Francois Laupretre <automap@tekwire.net>
* @license http://www.apache.org/licenses/LICENSE-2.0 Apache License, V 2.0
* @category Automap
* @package Automap
*///==========================================================================

//=============================================================================
/**
* A map instance (created from an existing map file)
*
* When the PECL extension is not present, this class is instantiated when the
* map is loaded, and it is used by the autoloader.
*
* When the extension is present, this class is instantiated only when explicitely
* referenced and is not used by the autoloader.
*
* API status: Public
* Included in the PHK PHP runtime: Yes
* Implemented in the extension: No
*///==========================================================================

namespace Automap {

if (!class_exists('Automap\Map',false)) 
{
class Map
{
/** Runtime API version */

const VERSION='3.0.0';

/** We cannot load maps older than this version */
 
const MIN_MAP_VERSION='3.0.0';

/** Map files start with this string */

const MAGIC="AUTOMAP  M\024\x8\6\3";// Magic value for map files (offset 0)

//--------------------------
/** The absolute path of the map file */

private $path;			

/** @var array(<key> => <target>)	The symbol table (filled from slots) */

private $symbols;

/** @var array(<ns> => <slot data>)	The symbols not loaded in the symbol table yet */

private $slots;

/** @var integer Symbol count of this map */

private $symcount;

/** @var array(<name> => <value>)	The map options */

private $options;

/** @var string The version of \Automap\Build\Creator that created the map file */

private $version;

/** @var string The minimum runtime version needed to understand the map file */

private $minVersion;

/** @var integer Load flags */

private $flags;

/** @var string Absolute base path */

private $basePath;

//-----
/**
* Construct a map object from an existing map file (real or virtual)
*
* @param string $path Path of the map file to read
* @param integer $flags Combination of Automap load flags (@see Automap)
* @param string Reserved for internal use (PHK). Never set this.
*/

public function __construct($path,$flags=0,$_bp=null)
{
$this->path=self::mkAbsolutePath($path);
$this->flags=$flags;

try
{
//-- Get file content

if (($buf=@file_get_contents($this->path))===false)
	throw new \Exception('Cannot read map file');
$bufsize=strlen($buf);
if ($bufsize<70) throw new \Exception("Short file (size=$bufsize)");

//-- Check magic

if (substr($buf,0,14)!=self::MAGIC) throw new \Exception('Bad Magic');

//-- Check min runtime version required by map

$this->minVersion=trim(substr($buf,14,12));	
if (version_compare($this->minVersion,self::VERSION) > 0)
	throw new \Exception($this->path.': Cannot understand this map.'.
		' Requires at least Automap version '.$this->minVersion);

//-- Check if the map format is not too old

$this->version=trim(substr($buf,26,12));
if (strlen($this->version)==0)
	throw new \Exception('Invalid empty map version');
if (version_compare($this->version,self::MIN_MAP_VERSION) < 0)
	throw new \Exception('Cannot understand this map. Format too old.');
$map_major_version=$this->version{0};

//-- Check file size

if (strlen($buf)!=($sz=(int)substr($buf,38,8)))
	throw new \Exception('Invalid file size. '.$sz.' should be '.strlen($buf));

//-- Check CRC

if (!($flags & Mgr::CRC_CHECK))
	{
	$crc=substr($buf,46,8);
	$buf=substr_replace($buf,'00000000',46,8);
	if ($crc!==hash('adler32',$buf)) throw new \Exception('CRC error');
	}

//-- Symbol count

$this->symcount=(int)substr($buf,54,8);

//-- Read data

$dsize=(int)substr($buf,62,8);
if (($buf=unserialize(substr($buf,70,$dsize)))===false)
	throw new \Exception('Cannot unserialize data from map file');
if (!is_array($buf))
	throw new \Exception('Map file should contain an array');
if (!array_key_exists('options',$buf)) throw new \Exception('No options array');
if (!is_array($this->options=$buf['options']))
	throw new \Exception('Options should be an array');
if (!array_key_exists('map',$buf)) throw new \Exception('No symbol table');
if (!is_array($this->slots=$buf['map']))
	throw new \Exception('Slot table should contain an array');
$this->symbols=array();

//-- Compute base path

if (!is_null($_bp)) $this->basePath=$_bp;
else $this->basePath=self::combinePath(dirname($this->path)
	,$this->option('basePath'),true);

}
catch (\Exception $e)
	{
	$this->symbols=array(); // No retry later
	throw new \Exception($path.': Cannot load map - '.$e->getMessage());
	}
}

//---------
// Check if a given file is a map file

public function isMapFile($path)
{
return (substr(file_get_contents($path),0,strlen(self::MAGIC))===self::MAGIC);
}

//---------
/**
* Combines a type and a symbol in a 'key'
*
* Starting with version 3.0, Automap is fully case-sensitive. This allows for
* higher performance and cleaner code.
*
* Do not use this method (reserved for use by other Automap classes)
*
* @param string $type one of the 'T_' constants
* @param string $name The symbol value (case sensitive)
* @return string Symbol key
*/

public static function key($type,$name)
{
return $type.trim($name,'\\');
}

//---------
/**
* Load a slot into the symbol table
*
* @param string $ns Normalized namespace. Must correspond to an existing slot (no check)
* @return null
*/

private function loadSlot($ns)
{
$this->symbols=array_merge($this->symbols,unserialize($this->slots[$ns]));
unset($this->slots[$ns]);
}

//---------
/**
* Extracts the namespace from a symbol name
*
* The returned value has no leading/trailing separator.
*
* Do not use: access reserved for Automap classes
*
* @param string $name The symbol value (case sensitive)
* @return string Namespace. If no namespace, returns an empty string.
*/

public static function nsKey($name)
{
$name=trim($name,'\\');
$pos=strrpos($name,'\\');
if ($pos!==false) return substr($name,0,$pos);
else return '';
}

//---
// These utility functions return 'read-only' properties

public function path() { return $this->path; }
public function flags() { return $this->flags; }
public function options() { return $this->options; }
public function version() { return $this->version; }
public function minVersion() { return $this->minVersion; }
public function basePath() { return $this->basePath; }

//---

public function option($opt)
{
return (isset($this->options[$opt]) ? $this->options[$opt] : null);
}

//---

public function symbolCount()
{
return $this->symcount;
}

//---
// The entry we are exporting must be in the symbol table (no check)
// We need to use combinePath() because the registered path (rpath) can be absolute

private function exportEntry($key)
{
$entry=$this->symbols[$key];

$a=array(
	'stype'		=> $key{0},
	'symbol' 	=> substr($key,1),
	'ptype'		=> $entry{0},
	'rpath'		=> substr($entry,1)
	);

$a['path']=(($a['ptype']===Mgr::F_EXTENSION) ? $a['rpath']
	: self::combinePath($this->basePath,$a['rpath']));

return $a;
}

//---

public function getSymbol($type,$symbol)
{
$key=self::key($type,$symbol);
if (!($found=array_key_exists($key,$this->symbols)))
	{
	if (count($this->slots))
		{
		$ns=self::nsKey($symbol);
		if (array_key_exists($ns,$this->slots)) $this->loadSlot($ns);
		$found=array_key_exists($key,$this->symbols);
		}
	}
return ($found ? $this->exportEntry($key) : false);
}

//-------
/**
* Try to resolve a symbol using this map
*
* For performance reasons, we trust the map and don't check if the symbol is
* defined after loading the script/extension/package.
*
* @param string $type One of the \Automap\Mgr::T_xxx symbol types
* @param string Symbol name including namespace (no leading '\')
* @param integer $id Used to return the ID of the map where the symbol was found
* @return exported entry if found, false if not found
*/

public function resolve($type,$name,&$id)
{
if (($this->flags & Mgr::NO_AUTOLOAD)
		|| (($entry=$this->getSymbol($type,$name))===false)) return false;

//-- Found

$path=$entry['path']; // Absolute path
switch($entry['ptype'])
	{
	case Mgr::F_EXTENSION:
		if (!dl($path)) return false;
		break;

	case Mgr::F_SCRIPT:
		//echo("Loading script file : $path\n");//TRACE
		{ require($path); }
		break;

	case Mgr::F_PACKAGE:
		// Remove E_NOTICE messages if the test script is a package - workaround
		// to PHP bug #39903 ('__COMPILER_HALT_OFFSET__ already defined')
		// In case of embedded packages and maps, the returned ID corresponds to
		// the map where the symbol was finally found.
	
		error_reporting(($errlevel=error_reporting()) & ~E_NOTICE);
		$mnt=require($path);
		error_reporting($errlevel);
		$pkg=\PHK\_Mgr::instance($mnt);
		$id=$pkg->automapID();
		return Mgr::map($id)->resolve($type,$name,$id);
		break;

	default:
		throw new \Exception('<'.$entry['ptype'].'>: Unknown target type');
	}
return $entry;
}

//---

public function symbols()
{
/* First, load every remaining slot */

foreach(array_keys($this->slots) as $ns) $this->loadSlot($ns);

/* Then, convert every entry to the export format */

$ret=array();
foreach(array_keys($this->symbols) as $key) $ret[]=$this->exportEntry($key);

return $ret;
}

//---
// Proxy to \Automap\Tools\Display::show()

public function show($format=null,$subfile_to_url_function=null)
{
return Tools\Display::show($this,$format,$subfile_to_url_function);
}

//---
// Proxy to \Automap\Tools\Check::check()

public function check()
{
return Tools\Check::check($this);
}

//---

public function export($path=null)
{
if (is_null($path)) $path="php://stdout";
$fp=fopen($path,'w');
if (!$fp) throw new \Exception("$path: Cannot open for writing");

foreach($this->symbols() as $s)
	{
	fwrite($fp,$s['stype'].'|'.$s['symbol'].'|'.$s['ptype'].'|'.$s['rpath']."\n");
	}

fclose($fp);
}

//---------------------------------
/**
* Transmits map elements to the PECL extension
*
* Reserved for internal use
*
* The first time a given map file is loaded, it is read by Automap\Map and
* transmitted to the extension. On subsequent requests, it is retrieved from
* persistent memory. This allows to code complex features in PHP and maintain
* the code in a single location without impacting performance.
*
* @param string $version The version of data to transmit (reserved for future use)
* @return array
*/

public function _peclGetMap($version)
{
$st=array();
foreach($this->symbols() as $s)
	{
	$st[]=array($s['stype'],$s['symbol'],$s['ptype'],$s['path']);
	}

return $st;
}

//============ Utilities (taken from external libs) ============
// We need to duplicate these methods here because this class is included in the
// PHK PHP runtime, which does not include the \Phool\xxx classes.

//----- Taken from \Phool\File
/**
* Combines a base path with another path
*
* The base path can be relative or absolute.
*
* The 2nd path can also be relative or absolute. If absolute, it is returned
* as-is. If it is a relative path, it is combined to the base path.
*
* Uses '/' as separator (to be compatible with stream-wrapper URIs).
*
* @param string $base The base path
* @param string|null $path The path to combine
* @param bool $separ true: add trailing sep, false: remove it
* @return string The resulting path
*/

private static function combinePath($base,$path,$separ=false)
{
if (($base=='.') || ($base=='') || self::isAbsolutePath($path))
	$res=$path;
elseif (($path=='.') || is_null($path))
	$res=$base;
else	//-- Relative path : combine it to base
	$res=rtrim($base,'/\\').'/'.$path;

return self::trailingSepar($res,$separ);
}

/**
* Adds or removes a trailing separator in a path
*
* @param string $path Input
* @param bool $flag true: add trailing sep, false: remove it
* @return bool The result path
*/

private static function trailingSepar($path, $separ)
{
$path=rtrim($path,'/\\');
if ($path=='') return '/';
if ($separ) $path=$path.'/';
return $path;
}

/**
* Determines if a given path is absolute or relative
*
* @param string $path The path to check
* @return bool True if the path is absolute, false if relative
*/

private static function isAbsolutePath($path)
{
return ((strpos($path,':')!==false)
	||(strpos($path,'/')===0)
	||(strpos($path,'\\')===0));
}

/**
* Build an absolute path from a given (absolute or relative) path
*
* If the input path is relative, it is combined with the current working
* directory.
*
* @param string $path The path to make absolute
* @param bool $separ True if the resulting path must contain a trailing separator
* @return string The resulting absolute path
*/

private static function mkAbsolutePath($path,$separ=false)
{
if (!self::isAbsolutePath($path)) $path=self::combinePath(getcwd(),$path);
return self::trailingSepar($path,$separ);
}

//---
} // End of class
//===========================================================================
} // End of class_exists
//===========================================================================
} // End of namespace
//===========================================================================
?>