openrat-cms

Unnamed repository; edit this file 'description' to name the repository.
Log | Files | Refs

commit 8461a4f4a1d9bf0650f8c23590465c0e330f8773
parent 67d4a6c660b2b3848358805e088c529b77db9b4d
Author: Jan Dankert <devnull@localhost>
Date:   Sat, 16 Dec 2017 23:21:31 +0100

Eigenes Modul für alle Util-Klassen.

Diffstat:
dispatcher.php | 4++--
init.php | 6+-----
modules/util/.htaccess | 3+++
modules/util/AbstractTree.class.php | 172+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/AdministrationTree.class.php | 595+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Api.class.php | 102+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/ArchiveTar.class.php | 398+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/ArchiveUnzip.class.php | 448+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/ArchiveZip.class.php | 90+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Code.class.php | 45+++++++++++++++++++++++++++++++++++++++++++++
modules/util/Dynamic.class.php | 35+++++++++++++++++++++++++++++++++++
modules/util/FileUtils.class.php | 103+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Ftp.class.php | 247+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/GlobalFunctions.class.php | 72++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Html.class.php | 179+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Http.class.php | 611+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/JSON.class.php | 809+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/JSqueeze.class.php | 1065+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Ldap.class.php | 183+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Less.php | 10525+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Line.class.php | 153+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Macro.class.php | 195+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Mail.class.php | 571+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/ProjectTree.class.php | 516+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Publish.class.php | 394+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Session.class.php | 243+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Spyc.class.php | 1161+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Text.class.php | 393+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Transformer.class.php | 103+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/TreeElement.class.php | 76++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/Upload.class.php | 86+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/XML.class.php | 170+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/config-default.php | 881+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
modules/util/exception/OpenRatException.class.php | 26++++++++++++++++++++++++++
modules/util/exception/SecurityException.class.php | 10++++++++++
modules/util/require.php | 33++++++++++++++++++++++++++++++---
util/.htaccess | 3---
util/AbstractTree.class.php | 172-------------------------------------------------------------------------------
util/AdministrationTree.class.php | 595-------------------------------------------------------------------------------
util/Api.class.php | 102-------------------------------------------------------------------------------
util/ArchiveTar.class.php | 398-------------------------------------------------------------------------------
util/ArchiveUnzip.class.php | 448-------------------------------------------------------------------------------
util/ArchiveZip.class.php | 90-------------------------------------------------------------------------------
util/Code.class.php | 45---------------------------------------------
util/Dynamic.class.php | 35-----------------------------------
util/FileUtils.class.php | 103-------------------------------------------------------------------------------
util/Ftp.class.php | 247-------------------------------------------------------------------------------
util/GlobalFunctions.class.php | 72------------------------------------------------------------------------
util/Html.class.php | 179-------------------------------------------------------------------------------
util/Http.class.php | 611-------------------------------------------------------------------------------
util/JSON.class.php | 809-------------------------------------------------------------------------------
util/JSqueeze.class.php | 1065-------------------------------------------------------------------------------
util/Ldap.class.php | 183-------------------------------------------------------------------------------
util/Less.php | 10525-------------------------------------------------------------------------------
util/Line.class.php | 153-------------------------------------------------------------------------------
util/Macro.class.php | 195-------------------------------------------------------------------------------
util/Mail.class.php | 571-------------------------------------------------------------------------------
util/ProjectTree.class.php | 516-------------------------------------------------------------------------------
util/Publish.class.php | 394-------------------------------------------------------------------------------
util/Session.class.php | 243-------------------------------------------------------------------------------
util/Spyc.class.php | 1161-------------------------------------------------------------------------------
util/Text.class.php | 393-------------------------------------------------------------------------------
util/Transformer.class.php | 103-------------------------------------------------------------------------------
util/TreeElement.class.php | 76----------------------------------------------------------------------------
util/Upload.class.php | 86-------------------------------------------------------------------------------
util/XML.class.php | 170-------------------------------------------------------------------------------
util/config-default.php | 881-------------------------------------------------------------------------------
util/exception/OpenRatException.class.php | 26--------------------------
util/exception/SecurityException.class.php | 10----------
util/include.inc.php | 66------------------------------------------------------------------
70 files changed, 20693 insertions(+), 20736 deletions(-)

diff --git a/dispatcher.php b/dispatcher.php @@ -37,7 +37,7 @@ try // Jetzt erst die Sitzung starten (nachdem alle Klassen zur Verfügung stehen). session_start(); - require_once( OR_SERVICECLASSES_DIR."Session.class.".PHP_EXT ); + require_once( OR_MODULES_DIR."util/Session.class.".PHP_EXT ); // Vorhandene Konfiguration aus der Sitzung lesen. $conf = Session::getConfig(); @@ -53,7 +53,7 @@ try // Fest eingebaute Standard-Konfiguration laden. $conf = array(); - require('./util/config-default.php'); // writes to $conf + require(OR_MODULES_DIR.'util/config-default.php'); // writes to $conf $customConfig = Configuration::load(); $conf = array_replace_recursive($conf, $customConfig); diff --git a/init.php b/init.php @@ -121,15 +121,11 @@ register_shutdown_function( "fatal_handler" ); require_once( "functions/request.inc.php" ); // Werkzeugklassen einbinden. -require_once( OR_SERVICECLASSES_DIR."include.inc.".PHP_EXT ); +require_once( OR_MODULES_DIR."util/require.".PHP_EXT ); require_once( OR_AUTHCLASSES_DIR."include.inc.".PHP_EXT ); - - - require_once( OR_MODULES_DIR."security/require.".PHP_EXT ); require_once( OR_MODULES_DIR."template-engine/require.".PHP_EXT ); -require_once( OR_MODULES_DIR."util/require.".PHP_EXT ); require_once( OR_MODULES_DIR."configuration/require.".PHP_EXT ); diff --git a/modules/util/.htaccess b/modules/util/.htaccess @@ -0,0 +1,2 @@ +order deny,allow +deny from all+ \ No newline at end of file diff --git a/modules/util/AbstractTree.class.php b/modules/util/AbstractTree.class.php @@ -0,0 +1,171 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Darstellen einer Baumstruktur mit Funktion zum Laden, Oeffnen und Schliessen + * von Teilbaeumen + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class AbstractTree +{ + /** + * Alle Elemente des Baumes + */ + var $elements = array(); + + var $tempElements = array(); + var $userIsAdmin = false; + + var $autoOpen = array(0,1); + + var $opened = array(); + + /** + * Hoechste Element-Id + * @type Integer + */ + var $maxId; + + // Konstruktor + function AbstractTree() + { + // Feststellen, ob der angemeldete Benutzer ein Administrator ist + $user = Session::getUser(); + $this->userIsAdmin = $user->isAdmin; + + // Wurzel-Element laden + $this->root(); + $this->elements[0] = $this->tempElements[0]; + $this->tempElements = array(); + $this->maxId = 0; + + foreach( $this->autoOpen as $openId ) + $this->open($openId); + } + + function refresh() { + + $this->elements = array(); + + // Wurzel-Element laden + $this->root(); + $this->elements[0] = $this->tempElements[0]; + $this->tempElements = array(); + $this->maxId = 0; + + $oids = $this->opened; + $this->opened = array(); + foreach( $oids as $oid) + { + if ( isset($this->elements[$oid]) ) + $this->open($oid); + } + } + + + + function all() { + + $this->elements = array(); + $this->opened = array(); + + // Wurzel-Element laden + $this->root(); + $this->elements[0] = $this->tempElements[0]; + $this->tempElements = array(); + $this->maxId = 0; + + for( $eid=0;isset($this->elements[$eid]); $eid++) + { + $this->open($eid); + } + } + + + /** + * Oeffnen eines Teilbaumes. Es wird der eindeutige Name des zu oeffnenden Teilbaumes als + * Parameter uebergeben + * @param elementName der Name des Elementes, welches zu oeffnen ist + */ + function open( $elementId ) + { + $k = array_search($elementId,$this->opened); + if ( $k !== false ) + return; // Ist schon offen. Evtl. Reload gedrückt? + + $this->opened[] = $elementId; + if ( ! isset($this->elements[$elementId]) ) + return; + $funcName = $this->elements[$elementId]->type; + if ( empty($funcName) ) + return; + + $this->$funcName( $this->elements[$elementId]->internalId ); + + // Wenn keine Unterelemente gefunden, dann die ?ffnen-Funktion deaktivieren + if ( count( $this->tempElements ) == 0 ) + $this->elements[$elementId]->type = ''; + + foreach( $this->tempElements as $treeElement ) + { + $this->maxId++; + $this->elements[$elementId]->subElementIds[] = $this->maxId; + $this->elements[$this->maxId] = $treeElement; + } + + if ( count($this->tempElements)==1 ) + { + $this->tempElements = array(); + $this->open($this->maxId); + } + + $this->tempElements = array(); + } + + + /** + * Schliessen eines Teilbaumes + * @param elementName der Name des Elementes, welches zu schliessen ist + */ + + function close( $elementId ) + { + $this->elements[$elementId]->subElementIds = array(); + + $k = array_search($elementId,$this->opened); + if ( $k !== false ) + unset($this->opened[$k]); + } + + + /** + * Hinzufuegen eines Baum-Elementes + * @param TreeElement Hinzuzufuegendes Baumelement + */ + function addTreeElement( $treeElement ) + { + $this->tempElements[] = $treeElement; + } + + +} + +?>+ \ No newline at end of file diff --git a/modules/util/AdministrationTree.class.php b/modules/util/AdministrationTree.class.php @@ -0,0 +1,594 @@ +<?php +use cms\model\User; +use cms\model\Project; +use cms\model\Group; +use cms\model\Folder; + +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Darstellen einer Baumstruktur mit Administrationfunktionen + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class AdministrationTree extends AbstractTree +{ + /** + * Alle Elemente des Baumes + */ + var $elements; + var $confCache = array(); + + function root() + { + if ( !$this->userIsAdmin ) + Http::notAuthorized('Administration-Tree is only visible for admins.'); + +// $treeElement = new TreeElement(); +// $treeElement->text = lang('GLOBAL_ADMINISTRATION'); +// $treeElement->description = lang('GLOBAL_ADMINISTRATION'); +// $treeElement->type = 'administration'; +// $treeElement->icon = 'administration'; + + $this->administration(); + + $this->autoOpen[] = 1; + } + + + + function administration() + { + global $conf; + $conf_config = $conf['interface']['config']; + + $treeElement = new TreeElement(); + $treeElement->id = 0; + $treeElement->text = lang('GLOBAL_PROJECTS'); + $treeElement->description = lang('GLOBAL_PROJECTS'); + $treeElement->url = Html::url('projectlist','show',0,array(REQ_PARAM_TARGET=>'content')); + $treeElement->action = 'projectlist'; + $treeElement->icon = 'projectlist'; + $treeElement->type = 'projects'; + $treeElement->target = 'cms_main'; + + $this->addTreeElement( $treeElement ); + + + $treeElement = new TreeElement(); + $treeElement->text = lang('USER_AND_GROUPS'); + $treeElement->description = lang('USER_AND_GROUPS'); + $treeElement->icon = 'userlist'; + $treeElement->type = 'userandgroups'; + + $this->addTreeElement( $treeElement ); +// $this->userandgroups(0);; + + if ( $conf_config['enable'] ) + { + $treeElement = new TreeElement(); + $treeElement->text = lang('PREFERENCES'); + $treeElement->description = lang('PREFERENCES'); + $treeElement->icon = 'configuration'; + //$treeElement->type = 'prefs'; + $treeElement->action = 'configuration'; + + $this->addTreeElement( $treeElement ); + } + + // Wechseln zu: Projekte... + /* + foreach( Project::getAll() as $id=>$name ) + { + $treeElement = new TreeElement(); + + $treeElement->text = lang('PROJECT').' '.$name; + $treeElement->url = Html::url(array('action' =>'tree', + 'subaction' =>'reload', + 'projectid' =>$id )); + $treeElement->icon = 'project'; + $treeElement->description = ''; + $treeElement->target = 'cms_tree'; + + $this->addTreeElement( $treeElement ); + } + */ + } + + + + function userandgroups( ) + { + $treeElement = new TreeElement(); + $treeElement->text = lang('GLOBAL_USER'); + $treeElement->description = lang('GLOBAL_USER'); + $treeElement->url = Html::url('user','listing',0,array(REQ_PARAM_TARGET=>'content')); + $treeElement->action = 'userlist'; + $treeElement->icon = 'userlist'; + $treeElement->target = 'cms_main'; + $treeElement->type = 'users'; + + $this->addTreeElement( $treeElement ); + + $treeElement = new TreeElement(); + $treeElement->text = lang('GLOBAL_GROUPS'); + $treeElement->description = lang('GLOBAL_GROUPS'); + $treeElement->url = Html::url('group','listing',0,array(REQ_PARAM_TARGET=>'content')); + $treeElement->action = 'grouplist'; + $treeElement->icon = 'userlist'; + $treeElement->target = 'cms_main'; + $treeElement->type = 'groups'; + + $this->addTreeElement( $treeElement ); + } + + + function projects( ) + { + // Schleife ueber alle Projekte + foreach(Project::getAllProjects() as $id=> $name ) + { + $treeElement = new TreeElement(); + + $treeElement->internalId = $id; + $treeElement->id = $id; + $treeElement->text = $name; + $treeElement->url = Html::url('project','edit',$id,array(REQ_PARAM_TARGET=>'content')); + $treeElement->icon = 'project'; + $treeElement->action = 'project'; + $treeElement->type = 'project'; + $treeElement->description = ''; + $treeElement->target = 'cms_main'; + + $this->addTreeElement( $treeElement ); + } + } + + + + function project( $projectid ) + { + $project = new Project( $projectid ); + + // Hoechster Ordner der Projektstruktur + $folder = new Folder( $project->getRootObjectId() ); + $folder->load(); + + + // Ermitteln, ob der Benutzer Projektadministrator ist + // Projektadministratoren haben das Recht, im Root-Ordner die Eigenschaften zu aendern. + if ( $folder->hasRight( ACL_PROP ) ) + $this->userIsProjectAdmin = true; + + if ( $folder->hasRight( ACL_READ ) ) + { + $treeElement = new TreeElement(); + $treeElement->id = $folder->objectid; + // $treeElement->text = $folder->name; + $treeElement->text = lang('FOLDER_ROOT'); + $treeElement->description = lang('FOLDER_ROOT_DESC'); + $treeElement->icon = 'folder'; + $treeElement->action = 'folder'; + $treeElement->url = Html::url( 'folder','',$folder->objectid,array(REQ_PARAM_TARGET=>'content') ); + $treeElement->target = 'content'; + $treeElement->type = 'folder'; + $treeElement->internalId = $folder->objectid; + $this->addTreeElement( $treeElement ); + } + + + if ( $this->userIsProjectAdmin ) + { + // Templates + $treeElement = new TreeElement(); + $treeElement->id = 0; + $treeElement->text = lang('GLOBAL_TEMPLATES'); + $treeElement->url = Html::url('template','listing',0,array(REQ_PARAM_TARGETSUBACTION=>'listing',REQ_PARAM_TARGET=>'content')); + $treeElement->description= lang('GLOBAL_TEMPLATES_DESC'); + $treeElement->icon = 'templatelist'; + $treeElement->action = 'templatelist'; + $treeElement->target = 'content'; + $treeElement->type = 'templates'; + $this->addTreeElement( $treeElement ); + } + + + // Sprachen + $treeElement = new TreeElement(); + $treeElement->description= ''; + $treeElement->id = 0; + $treeElement->action = 'languagelist'; + $treeElement->text = lang('GLOBAL_LANGUAGES'); + $treeElement->url = Html::url('language','listing',0,array(REQ_PARAM_TARGETSUBACTION=>'listing',REQ_PARAM_TARGET=>'content')); + $treeElement->icon = 'languagelist'; + $treeElement->description= lang('GLOBAL_LANGUAGES_DESC'); + $treeElement->target = 'content'; + + // Nur fuer Projekt-Administratoren aufklappbar + if ( $this->userIsProjectAdmin ) + $treeElement->type = 'languages'; + + $this->addTreeElement( $treeElement ); + + + // Projektmodelle + $treeElement = new TreeElement(); + $treeElement->description= ''; + + // Nur fuer Projekt-Administratoren aufklappbar + if ( $this->userIsProjectAdmin ) + $treeElement->type = 'models'; + + $treeElement->id = 0; + $treeElement->description= lang('GLOBAL_MODELS_DESC'); + $treeElement->text = lang('GLOBAL_MODELS'); + $treeElement->url = Html::url('model','listing',0,array(REQ_PARAM_TARGETSUBACTION=>'listing',REQ_PARAM_TARGET=>'content')); + $treeElement->action = 'modellist'; + $treeElement->icon = 'modellist'; + $treeElement->target = 'content'; + $this->addTreeElement( $treeElement ); + + + // Sonstiges + // $treeElement = new TreeElement(); + // $treeElement->text = lang('GLOBAL_OTHER'); + // $treeElement->description= lang('GLOBAL_OTHER_DESC'); + // $treeElement->icon = 'other'; + // $treeElement->type = 'other'; + // $this->addTreeElement( $treeElement ); + + // Suche + $treeElement = new TreeElement(); + $treeElement->id = 0; + $treeElement->text = lang('GLOBAL_SEARCH'); + $treeElement->url = Html::url('search','',0,array(REQ_PARAM_TARGET=>'content')); + $treeElement->action = 'search'; + $treeElement->icon = 'search'; + $treeElement->description = lang('GLOBAL_SEARCH_DESC'); + $treeElement->target = 'content'; + $this->addTreeElement( $treeElement ); + + } + + + + function prefs_system( ) + { + $system = array( 'time' => date('r'), + 'os' => php_uname('s'), + 'host' => php_uname('n'), + 'release'=> php_uname('r'), + 'machine'=> php_uname('m'), + 'owner' => get_current_user(), + 'pid' => getmypid() ); + + foreach( $system as $key=>$value ) + { + $treeElement = new TreeElement(); + $treeElement->text = $key.'='.$value; + $treeElement->icon = 'config_property'; + $this->addTreeElement( $treeElement ); + $treeElement->description = lang('SETTING')." '".$key."'".(!empty($value)?': '.$value:''); + } + + if ( function_exists('getrusage') ) // Funktion existiert auf WIN32 nicht. + { + foreach( getrusage() as $name=>$value ); + { + $treeElement = new TreeElement(); + $treeElement->text = $name.':'.$value; + $treeElement->description = lang('SETTING')." '".$name."'".(!empty($value)?': '.$value:''); + $treeElement->icon = 'config_property'; + $this->addTreeElement( $treeElement ); + } + } + } + + + + + function prefs_php( ) + { + $php_prefs = array( 'version' => phpversion(), + 'SAPI' => php_sapi_name(), + 'session-name' => session_name(), + 'magic_quotes_gpc' => get_magic_quotes_gpc(), + 'magic_quotes_runtime'=> get_magic_quotes_runtime() ); + + foreach( array('upload_max_filesize', + 'file_uploads', + 'memory_limit', + 'max_execution_time', + 'post_max_size', + 'display_errors', + 'register_globals' + ) as $iniName ) + $php_prefs[ $iniName ] = ini_get( $iniName ); + + foreach( $php_prefs as $key=>$value ) + { + $treeElement = new TreeElement(); + $treeElement->text = $key.'='.$value; + $treeElement->description = lang('SETTING')." '".$key."'".(!empty($value)?': '.$value:''); + $treeElement->icon = 'config_property'; + $this->addTreeElement( $treeElement ); + } + } + + + + function prefs_extensions( ) + { + $extensions = get_loaded_extensions(); + asort( $extensions ); + + foreach( $extensions as $id=>$extensionName ) + { + $treeElement = new TreeElement(); + $treeElement->text = $extensionName; + $treeElement->icon = 'config_property'; + $treeElement->internalId = $id; + $this->addTreeElement( $treeElement ); + } + } + + + + function prefs_extension( $id ) + { + $extensions = get_loaded_extensions(); + $functions = get_extension_funcs( $extensions[$id] ); + asort( $functions ); + + foreach( $functions as $functionName ) + { + $treeElement = new TreeElement(); + $treeElement->text = $functionName; + $treeElement->icon = 'config_property'; + $this->addTreeElement( $treeElement ); + } + } + + + /** + * Anzeigen von Einstellungen. + * + * @param $id + */ + function prefs( ) + { + global $conf; + + if ( !@$conf['security']['show_system_info'] ) + return; + + $conf_config = $conf['interface']['config']; + + + $treeElement = new TreeElement(); + + $treeElement->internalId = -1; + $treeElement->text = 'OpenRat'; + $treeElement->icon = 'configuration'; + + if ( !empty($conf_config['file_manager_url']) ) + $treeElement->url = $conf_config['file_manager_url']; + $treeElement->target = '_blank'; + $treeElement->description = ''; + $treeElement->type = 'prefs_cms'; + $this->addTreeElement( $treeElement ); + + + + if ( !empty($conf_config['show_system']) ) + { + $treeElement = new TreeElement(); + + $treeElement->internalId = 0; + $treeElement->text = lang('GLOBAL_SYSTEM'); + $treeElement->icon = 'configuration'; + + $treeElement->description = ''; + $treeElement->target = 'cms_main'; + $treeElement->type = 'prefs_system'; + $this->addTreeElement( $treeElement ); + } + + + if ( !empty($conf_config['show_interpreter']) ) + { + $treeElement = new TreeElement(); + + $treeElement->internalId = 0; + $treeElement->text = lang('GLOBAL_PHP'); + $treeElement->icon = 'configuration'; + + $treeElement->description = ''; + $treeElement->target = 'cms_main'; + $treeElement->type = 'prefs_php'; + $this->addTreeElement( $treeElement ); + } + + + if ( !empty($conf_config['show_extensions']) ) + { + $treeElement = new TreeElement(); + + $treeElement->internalId = 0; + $treeElement->text = lang('GLOBAL_EXTENSIONS'); + $treeElement->icon = 'configuration'; + + $treeElement->description = ''; + $treeElement->target = 'cms_main'; + $treeElement->type = 'prefs_extensions'; + $this->addTreeElement( $treeElement ); + } + } + + + function prefs_cms( $id ) + { + global $conf; + + if ( $id < 0 ) + { + $tmpConf = $conf; + } + else + $tmpConf = $this->confCache[$id]; + + if ( !is_array($tmpConf) ) + $tmpConf = array('unknown'); + + foreach( $tmpConf as $key=>$value ) + { + if ( is_array($value) ) + { + $this->confCache[crc32($key)] = $value; + + $treeElement = new TreeElement(); + + $treeElement->internalId = crc32($key); + $treeElement->text = $key; +// if ( $id == 0 ) +// $treeElement->url = Html::url('main','prefs',0,array('conf'=>$key)); + $treeElement->icon = 'configuration'; + + $treeElement->description = count($value).' '.lang('SETTINGS'); + $treeElement->target = 'cms_main'; + $treeElement->type = 'prefs_cms'; + $this->addTreeElement( $treeElement ); + } + else + { + // Die PHP-funktion 'parse_ini_file()' liefert alle Einstellungen leider nur als String + // Daher weiß man hier nicht, ob '1' nun '1' oder 'true' heißen soll. + if ( $value=='' ) + // Anzeige 'Leer' + $value = lang('EMPTY'); + elseif ( $value=='0' ) + // Anzeige 'Nein' + $value = $value.' ('.lang('IS_NO').')'; + elseif ( $value=='1' ) + // Anzeige 'Ja' + $value = '+'.$value.' ('.lang('IS_YES').')'; + elseif ( is_numeric($value) ) + // Anzeige numerische Werte + $value = ($value>0?'+':'').$value; + else + // Anzeige von Zeichenketten + $value = $value; + + $this->confCache[crc32($key)] = $value; + + if ( strpos($key,'pass') !== FALSE ) + $value = '***'; // Kennwörter nicht anzeigen + + $treeElement = new TreeElement(); + $treeElement->text = $key.': '.$value; + $treeElement->icon = 'config_property'; + $treeElement->description = lang('SETTING')." '".$key."'".(!empty($value)?': '.$value:''); + + $this->addTreeElement( $treeElement ); + } + } + } + + + function users( ) + { + foreach( User::getAllUsers() as $user ) + { + $treeElement = new TreeElement(); + $treeElement->id = $user->userid; + $treeElement->internalId = $user->userid; + $treeElement->text = $user->name; + $treeElement->url = Html::url('user','edit', + $user->userid,array(REQ_PARAM_TARGET=>'content') ); + $treeElement->action = 'user'; + $treeElement->icon = 'user'; + + $desc = $user->fullname; + + if ( $user->isAdmin ) + $desc .= ' ('.lang('USER_ADMIN').') '; + if ( $user->desc == "" ) + $desc .= ' - '.lang('GLOBAL_NO_DESCRIPTION_AVAILABLE'); + else + $desc .= ' - '.$user->desc; + + $treeElement->description = $desc; + $treeElement->target = 'cms_main'; + + $this->addTreeElement( $treeElement ); + } + } + + + function groups( ) + { + + foreach( Group::getAll() as $id=>$name ) + { + $treeElement = new TreeElement(); + + $g = new Group( $id ); + $g->load(); + + $treeElement->id = $id; + $treeElement->internalId = $id; + $treeElement->text = $g->name; + $treeElement->url = Html::url('group','edit',$id, + array(REQ_PARAM_TARGET=>'content') ); + $treeElement->icon = 'group'; + $treeElement->description = lang('GLOBAL_GROUP').' '.$g->name.': '.implode(', ',$g->getUsers()); + $treeElement->target = 'cms_main'; + $treeElement->type = 'userofgroup'; + $treeElement->action = 'group'; + + $this->addTreeElement( $treeElement ); + } + } + + + function userofgroup( $id ) + { + $g = new Group( $id ); + + foreach( $g->getUsers() as $id=>$name ) + { + $treeElement = new TreeElement(); + + $u = new User( $id ); + $u->load(); + $treeElement->id = $u->userid; + $treeElement->text = $u->name; + $treeElement->url = Html::url('user','edit',$id,array(REQ_PARAM_TARGET=>'content')); + $treeElement->icon = 'user'; + $treeElement->action = 'user'; + $treeElement->description = $u->fullname; + $treeElement->target = 'cms_main'; + + $this->addTreeElement( $treeElement ); + } + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/Api.class.php b/modules/util/Api.class.php @@ -0,0 +1,101 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. +use cms\model\Folder; + + +/** + * Service-Klasse fuer allgemeine Interface-Methoden. Insbesondere + * in Code-Elementen kann und soll auf diese Methoden zurueckgegriffen + * werden. + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class Api +{ + var $output = ''; + var $objectid = 0; + var $page; + + function db() + { + return db_connection(); + } + + function pageid() + { + echo 'WARNING: pageid() deprecated!<br>'; + global $SESS; + return $SESS['objectid']; + } + + function getObjectId() + { + return $this->objectid; + } + + function setObjectId( $objectid ) + { + $this->objectid = $objectid; + } + + function getRootObjectId() + { + return Folder::getRootObjectId(); + } + + function folderid() + { + global $SESS; + return $SESS['folderid']; + } + + + function execute( $code ) + { + global $conf_tmpdir; + $code = "<?php\n".$code."\n?>"; + + $tmp = $conf_tmpdir.'/'.md5(microtime()).'.tmp'; + $f = fopen( $tmp,'w' ); + fwrite( $f,$code ); + fclose( $f ); + + require( $tmp ); // Ausfuehren des temporaeren PHP-Codes + + unlink( $tmp ); + $inhalt = Api::getOutput(); + $this->output( $inhalt ); + } + + function delOutput() + { + $this->output = ''; + } + + function output( $text ) + { + $this->output .= $text; + } + + + function getOutput() + { + return $this->output; + } +}+ \ No newline at end of file diff --git a/modules/util/ArchiveTar.class.php b/modules/util/ArchiveTar.class.php @@ -0,0 +1,397 @@ +<?php +/* +======================================================================= +Name: + tar Class + +Author: + Josh Barger <joshb@npt.com> + +Description: + This class reads and writes Tape-Archive (TAR) Files and Gzip + compressed TAR files, which are mainly used on UNIX systems. + This class works on both windows AND unix systems, and does + NOT rely on external applications!! Woohoo! + +Usage: + Copyright (C) 2002 Josh Barger + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details at: + http://www.gnu.org/copyleft/lesser.html + + If you use this script in your application/website, please + send me an e-mail letting me know about it :) + +Bugs: + Please report any bugs you might find to my e-mail address + at joshb@npt.com. If you have already created a fix/patch + for the bug, please do send it to me so I can incorporate it into my release. + +Version History: + 1.0 04/10/2002 - InitialRelease + + 2.0 04/11/2002 - Merged both tarReader and tarWriter + classes into one + - Added support for gzipped tar files + Remember to name for .tar.gz or .tgz + if you use gzip compression! + :: THIS REQUIRES ZLIB EXTENSION :: + - Added additional comments to + functions to help users + - Added ability to remove files and + directories from archive + 2.1 04/12/2002 - Fixed serious bug in generating tar + - Created another example file + - Added check to make sure ZLIB is + installed before running GZIP + compression on TAR + 2.2 05/07/2002 - Added automatic detection of Gzipped + tar files (Thanks go to J�rgen Falch + for the idea) + - Changed "private" functions to have + special function names beginning with + two underscores +======================================================================= +*/ + + +class ArchiveTar +{ + // Unprocessed Archive Information + var $filename; + var $isGzipped; + var $tar_file; + + // Processed Archive Information + var $files; + var $directories; + var $numFiles; + var $numDirectories; + + + // Class Constructor -- Does nothing... + function tar() { + return true; + } + + + // Computes the unsigned Checksum of a file's header + // to try to ensure valid file + // PRIVATE ACCESS FUNCTION + function __computeUnsignedChecksum($bytestring) + { + $unsigned_chksum=0; + for($i=0; $i<512; $i++) + $unsigned_chksum += ord($bytestring[$i]); + for($i=0; $i<8; $i++) + $unsigned_chksum -= ord($bytestring[148 + $i]); + $unsigned_chksum += ord(" ") * 8; + + return $unsigned_chksum; + } + + + // Converts a NULL padded string to a non-NULL padded string + // PRIVATE ACCESS FUNCTION + function __parseNullPaddedString($string) + { + $position = strpos($string,chr(0)); + return substr($string,0,$position); + } + + + // This function parses the current TAR file + // PRIVATE ACCESS FUNCTION + function __parseTar() + { + // Read Files from archive + $this->numFiles=0; + $tar_length = strlen($this->tar_file); + $main_offset = 0; + while($main_offset < $tar_length) { + // If we read a block of 512 nulls, we are at the end of the archive + if(substr($this->tar_file,$main_offset,512) == str_repeat(chr(0),512)) + break; + + // Parse file name + $file_name = $this->__parseNullPaddedString(substr($this->tar_file,$main_offset,100)); + + // Parse the file mode + $file_mode = substr($this->tar_file,$main_offset + 100,8); + + // Parse the file user ID + $file_uid = octdec(substr($this->tar_file,$main_offset + 108,8)); + + // Parse the file group ID + $file_gid = octdec(substr($this->tar_file,$main_offset + 116,8)); + + // Parse the file size + $file_size = octdec(substr($this->tar_file,$main_offset + 124,12)); + + // Parse the file update time - unix timestamp format + $file_time = octdec(substr($this->tar_file,$main_offset + 136,12)); + + // Parse Checksum + $file_chksum = octdec(substr($this->tar_file,$main_offset + 148,6)); + + // Parse user name + $file_uname = $this->__parseNullPaddedString(substr($this->tar_file,$main_offset + 265,32)); + + // Parse Group name + $file_gname = $this->__parseNullPaddedString(substr($this->tar_file,$main_offset + 297,32)); + + // Make sure our file is valid + if($this->__computeUnsignedChecksum(substr($this->tar_file,$main_offset,512)) != $file_chksum) + return false; + + // Parse File Contents + $file_contents = substr($this->tar_file,$main_offset + 512,$file_size); + + /* ### Unused Header Information ### + $activeFile["typeflag"] = substr($this->tar_file,$main_offset + 156,1); + $activeFile["linkname"] = substr($this->tar_file,$main_offset + 157,100); + $activeFile["magic"] = substr($this->tar_file,$main_offset + 257,6); + $activeFile["version"] = substr($this->tar_file,$main_offset + 263,2); + $activeFile["devmajor"] = substr($this->tar_file,$main_offset + 329,8); + $activeFile["devminor"] = substr($this->tar_file,$main_offset + 337,8); + $activeFile["prefix"] = substr($this->tar_file,$main_offset + 345,155); + $activeFile["endheader"] = substr($this->tar_file,$main_offset + 500,12); + */ + + if($file_size > 0) { + // Increment number of files + $this->numFiles++; + + // Create us a new file in our array + $activeFile = &$this->files[]; + + // Asign Values + $activeFile["name"] = $file_name; + $activeFile["mode"] = $file_mode; + $activeFile["size"] = $file_size; + $activeFile["time"] = $file_time; + $activeFile["user_id"] = $file_uid; + $activeFile["group_id"] = $file_gid; + $activeFile["user_name"] = $file_uname; + $activeFile["group_name"] = $file_gname; + $activeFile["checksum"] = $file_chksum; + $activeFile["file"] = $file_contents; + + } else { + // Increment number of directories + $this->numDirectories++; + + // Create a new directory in our array + $activeDir = &$this->directories[]; + + // Assign values + $activeDir["name"] = $file_name; + $activeDir["mode"] = $file_mode; + $activeDir["time"] = $file_time; + $activeDir["user_id"] = $file_uid; + $activeDir["group_id"] = $file_gid; + $activeDir["user_name"] = $file_uname; + $activeDir["group_name"] = $file_gname; + $activeDir["checksum"] = $file_chksum; + } + + // Move our offset the number of blocks we have processed + $main_offset += 512 + (ceil($file_size / 512) * 512); + } + + return true; + } + + + // Read a non gzipped tar file in for processing + // PRIVATE ACCESS FUNCTION + function __readTar($filename='') + { + // Set the filename to load + // Read in the TAR file + + if($this->tar_file[0] == chr(31) && $this->tar_file[1] == chr(139) && $this->tar_file[2] == chr(8)) { + if(!function_exists("gzinflate")) + return false; + + $this->isGzipped = TRUE; + + $this->tar_file = gzinflate(substr($this->tar_file,10,-4)); + } + + // Parse the TAR file + $this->__parseTar(); + + return true; + } + + + // Generates a TAR file from the processed data + // PRIVATE ACCESS FUNCTION + function __generateTAR() + { + // Clear any data currently in $this->tar_file + unset($this->tar_file); + + // Generate Records for each directory, if we have directories + if($this->numDirectories > 0) { + foreach($this->directories as $key => $information) { + unset($header); + + // Generate tar header for this directory + // Filename, Permissions, UID, GID, size, Time, checksum, typeflag, linkname, magic, version, user name, group name, devmajor, devminor, prefix, end + $header .= str_pad($information["name"],100,chr(0)); + $header .= str_pad(decoct($information["mode"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["user_id"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["group_id"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct(0),11,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["time"]),11,"0",STR_PAD_LEFT) . chr(0); + $header .= str_repeat(" ",8); + $header .= "5"; + $header .= str_repeat(chr(0),100); + $header .= str_pad("ustar",6,chr(32)); + $header .= chr(32) . chr(0); + $header .= str_pad("",32,chr(0)); + $header .= str_pad("",32,chr(0)); + $header .= str_repeat(chr(0),8); + $header .= str_repeat(chr(0),8); + $header .= str_repeat(chr(0),155); + $header .= str_repeat(chr(0),12); + + // Compute header checksum + $checksum = str_pad(decoct($this->__computeUnsignedChecksum($header)),6,"0",STR_PAD_LEFT); + for($i=0; $i<6; $i++) { + $header[(148 + $i)] = substr($checksum,$i,1); + } + $header[154] = chr(0); + $header[155] = chr(32); + + // Add new tar formatted data to tar file contents + $this->tar_file .= $header; + } + } + + // Generate Records for each file, if we have files (We should...) + if($this->numFiles > 0) + { + foreach($this->files as $key => $information) + { + unset($header); + $header = ''; + + // Generate the TAR header for this file + // Filename, Permissions, UID, GID, size, Time, checksum, typeflag, linkname, magic, version, user name, group name, devmajor, devminor, prefix, end + $header .= str_pad($information["name"],100,chr(0)); + $header .= str_pad(decoct($information["mode"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["user_id"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["group_id"]),7,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["size"]),11,"0",STR_PAD_LEFT) . chr(0); + $header .= str_pad(decoct($information["time"]),11,"0",STR_PAD_LEFT) . chr(0); + $header .= str_repeat(" ",8); + $header .= "0"; + $header .= str_repeat(chr(0),100); + $header .= str_pad("ustar",6,chr(32)); + $header .= chr(32) . chr(0); + $header .= str_pad($information["user_name"],32,chr(0)); // How do I get a file's user name from PHP? + $header .= str_pad($information["group_name"],32,chr(0)); // How do I get a file's group name from PHP? + $header .= str_repeat(chr(0),8); + $header .= str_repeat(chr(0),8); + $header .= str_repeat(chr(0),155); + $header .= str_repeat(chr(0),12); + + // Compute header checksum + $checksum = str_pad(decoct($this->__computeUnsignedChecksum($header)),6,"0",STR_PAD_LEFT); + for($i=0; $i<6; $i++) + { + $header[(148 + $i)] = substr($checksum,$i,1); + } + $header[154] = chr(0); + $header[155] = chr(32); + + // Pad file contents to byte count divisible by 512 + $file_contents = str_pad($information["file"],(ceil($information["size"] / 512) * 512),chr(0)); + + // Add new tar formatted data to tar file contents + $this->tar_file .= $header . $file_contents; + } + } + + // Add 512 bytes of NULLs to designate EOF + $this->tar_file .= str_repeat(chr(0),512); + + return true; + } + + + // Open a TAR file + function openTAR($value) + { + // Clear any values from previous tar archives + unset($this->filename); + unset($this->isGzipped); + unset($this->tar_file); + unset($this->files); + unset($this->directories); + unset($this->numFiles); + unset($this->numDirectories); + + $this->filename = 'none'; + $this->tar_file = $value; + // Parse this file + $this->__readTar(); + + return true; + } + + + // Write the currently loaded tar archive to disk + function saveTar() + { + if(!$this->filename) + return false; + + // Write tar to current file using specified gzip compression + $this->toTar($this->filename,$this->isGzipped); + + return true; + } + + + // Saves tar archive to a different file than the current file + function toTar($filename,$useGzip) + { + if(!$filename) + return false; + + // Encode processed files into TAR file format + $this->__generateTar(); + + // GZ Compress the data if we need to + if($useGzip) { + // Make sure we have gzip support + if(!function_exists("gzencode")) + return false; + + $file = gzencode($this->tar_file); + } else { + $file = $this->tar_file; + } + + // Write the TAR file + $fp = fopen($filename,"wb"); + fwrite($fp,$file); + fclose($fp); + + return true; + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/ArchiveUnzip.class.php b/modules/util/ArchiveUnzip.class.php @@ -0,0 +1,447 @@ +<?php +// 28/11/2005 (2.4) +// - dUnzip2 is now compliant with wrong placed "Data Description", made by some compressors, +// like the classes ZipLib and ZipLib2 by 'Hasin Hayder'. Thanks to Ricardo Parreno for pointing it. +// 09/11/2005 (2.3) +// - Added optional parameter '$stopOnFile' on method 'getList()'. +// If given, file listing will stop when find given filename. (Useful to open and unzip an exact file) +// 06/11/2005 (2.21) +// - Added support to PK00 file format (Packed to Removable Disk) (thanks to Lito [PHPfileNavigator]) +// - Method 'getExtraInfo': If requested file doesn't exist, return FALSE instead of Array() +// 31/10/2005 (2.2) +// - Removed redundant 'file_name' on centralDirs declaration (thanks to Lito [PHPfileNavigator]) +// - Fixed redeclaration of file_put_contents when in PHP4 (not returning true) + +############################################################## +# Class dUnzip2 v2.4 +# +# Author: Alexandre Tedeschi (d) +# E-Mail: alexandrebr at gmail dot com +# Londrina - PR / Brazil +# +# Objective: +# This class allows programmer to easily unzip files on the fly. +# +# Requirements: +# This class requires extension ZLib Enabled. It is default +# for most site hosts around the world, and for the PHP Win32 dist. +# +# To do: +# * Error handling +# * Write a PHP-Side gzinflate, to completely avoid any external extensions +# * Write other decompress algorithms +# +# If you modify this class, or have any ideas to improve it, please contact me! +# You are allowed to redistribute this class, if you keep my name and contact e-mail on it. +############################################################## + +class ArchiveUnzip{ + + // Public + var $files = array(); + var $value = ''; + var $fileName; + var $compressedList; // You will problably use only this one! + var $centralDirList; // Central dir list... It's a kind of 'extra attributes' for a set of files + var $endOfCentral; // End of central dir, contains ZIP Comments + var $debug; + + // Private + var $fh; + var $zipSignature = "\x50\x4b\x03\x04"; // local file header signature + var $dirSignature = "\x50\x4b\x01\x02"; // central dir header signature + var $dirSignatureE= "\x50\x4b\x05\x06"; // end of central dir signature + + // Public + Function ArchiveUnzip() + { + $this->compressedList = + $this->centralDirList = + $this->endOfCentral = Array(); + } + + function open( $value ) + { + $this->fileName = tempnam('/tmp','unzip'); +// echo $this->fileName; + $fo = fopen( $this->fileName,'w'); + fwrite($fo,$value); + $this->unzipAll(); + } + + + Function getList($stopOnFile=false){ + if(sizeof($this->compressedList)){ + $this->debugMsg(1, "Returning already loaded file list."); + return $this->compressedList; + } + + // Open file, and set file handler + $fh = fopen($this->fileName, "r"); + $this->fh = &$fh; + if(!$fh){ + $this->debugMsg(2, "Failed to load file."); + return false; + } + + // Loop the file, looking for files and folders + $ddTry = false; + fseek($fh, 0); + for(;;){ + // Check if the signature is valid... + $signature = fread($fh, 4); + if(feof($fh)){ +# $this->debugMsg(1, "Reached end of file"); + break; + } + + // If signature is a 'Packed to Removable Disk', just ignore it and move to the next. + if($signature == 'PK00'){ + $this->debugMsg(1, "Found PK00: Packed to Removable Disk"); + continue; + } + + // If signature of a 'Local File Header' + if($signature == $this->zipSignature){ + # $this->debugMsg(1, "Zip Signature!"); + + // Get information about the zipped file + $file['version_needed'] = unpack("v", fread($fh, 2)); // version needed to extract + $file['general_bit_flag'] = unpack("v", fread($fh, 2)); // general purpose bit flag + $file['compression_method'] = unpack("v", fread($fh, 2)); // compression method + $file['lastmod_time'] = unpack("v", fread($fh, 2)); // last mod file time + $file['lastmod_date'] = unpack("v", fread($fh, 2)); // last mod file date + $file['crc-32'] = fread($fh, 4); // crc-32 + $file['compressed_size'] = unpack("V", fread($fh, 4)); // compressed size + $file['uncompressed_size'] = unpack("V", fread($fh, 4)); // uncompressed size + $fileNameLength = unpack("v", fread($fh, 2)); // filename length + $extraFieldLength = unpack("v", fread($fh, 2)); // extra field length + $file['file_name'] = fread($fh, $fileNameLength[1]); // filename + $file['extra_field'] = $extraFieldLength[1]?fread($fh, $extraFieldLength[1]):''; // extra field + $file['contents-startOffset']= ftell($fh); + + // Bypass the whole compressed contents, and look for the next file + fseek($fh, $file['compressed_size'][1], SEEK_CUR); + + // Convert the date and time, from MS-DOS format to UNIX Timestamp + $BINlastmod_date = str_pad(decbin($file['lastmod_date'][1]), 16, '0', STR_PAD_LEFT); + $BINlastmod_time = str_pad(decbin($file['lastmod_time'][1]), 16, '0', STR_PAD_LEFT); + $lastmod_dateY = bindec(substr($BINlastmod_date, 0, 7))+1980; + $lastmod_dateM = bindec(substr($BINlastmod_date, 7, 4)); + $lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5)); + $lastmod_timeH = bindec(substr($BINlastmod_time, 0, 5)); + $lastmod_timeM = bindec(substr($BINlastmod_time, 5, 6)); + $lastmod_timeS = bindec(substr($BINlastmod_time, 11, 5)); + + // Mount file table + $this->compressedList[$file['file_name']] = Array( + 'file_name' =>$file['file_name'], + 'compression_method'=>$file['compression_method'][1], + 'version_needed' =>$file['version_needed'][1], + 'lastmod_datetime' =>mktime($lastmod_timeH, $lastmod_timeM, $lastmod_timeS, $lastmod_dateM, $lastmod_dateD, $lastmod_dateY), + 'crc-32' =>str_pad(dechex(ord($file['crc-32'][3])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][2])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][1])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][0])), 2, '0', STR_PAD_LEFT), + 'compressed_size' =>$file['compressed_size'][1], + 'uncompressed_size' =>$file['uncompressed_size'][1], + 'extra_field' =>$file['extra_field'], + 'general_bit_flag' =>str_pad(decbin($file['general_bit_flag'][1]), 8, '0', STR_PAD_LEFT), + 'contents-startOffset'=>$file['contents-startOffset'] + ); + + if($stopOnFile) if($file['file_name'] == $stopOnFile){ + $this->debugMsg(1, "Stopping on file..."); + break; + } + } + + // If signature of a 'Central Directory Structure' + elseif($signature == $this->dirSignature){ + # $this->debugMsg(1, "Dir Signature!"); + + $dir['version_madeby'] = unpack("v", fread($fh, 2)); // version made by + $dir['version_needed'] = unpack("v", fread($fh, 2)); // version needed to extract + $dir['general_bit_flag'] = unpack("v", fread($fh, 2)); // general purpose bit flag + $dir['compression_method'] = unpack("v", fread($fh, 2)); // compression method + $dir['lastmod_time'] = unpack("v", fread($fh, 2)); // last mod file time + $dir['lastmod_date'] = unpack("v", fread($fh, 2)); // last mod file date + $dir['crc-32'] = fread($fh, 4); // crc-32 + $dir['compressed_size'] = unpack("V", fread($fh, 4)); // compressed size + $dir['uncompressed_size'] = unpack("V", fread($fh, 4)); // uncompressed size + $fileNameLength = unpack("v", fread($fh, 2)); // filename length + $extraFieldLength = unpack("v", fread($fh, 2)); // extra field length + $fileCommentLength = unpack("v", fread($fh, 2)); // file comment length + $dir['disk_number_start'] = unpack("v", fread($fh, 2)); // disk number start + $dir['internal_attributes'] = unpack("v", fread($fh, 2)); // internal file attributes-byte1 + $dir['external_attributes1']= unpack("v", fread($fh, 2)); // external file attributes-byte2 + $dir['external_attributes2']= unpack("v", fread($fh, 2)); // external file attributes + $dir['relative_offset'] = unpack("V", fread($fh, 4)); // relative offset of local header + $dir['file_name'] = fread($fh, $fileNameLength[1]); // filename + $dir['extra_field'] = $extraFieldLength[1] ?fread($fh, $extraFieldLength[1]) :''; // extra field + $dir['file_comment'] = $fileCommentLength[1]?fread($fh, $fileCommentLength[1]):''; // file comment + + // Convert the date and time, from MS-DOS format to UNIX Timestamp + $BINlastmod_date = str_pad(decbin($file['lastmod_date'][1]), 16, '0', STR_PAD_LEFT); + $BINlastmod_time = str_pad(decbin($file['lastmod_time'][1]), 16, '0', STR_PAD_LEFT); + $lastmod_dateY = bindec(substr($BINlastmod_date, 0, 7))+1980; + $lastmod_dateM = bindec(substr($BINlastmod_date, 7, 4)); + $lastmod_dateD = bindec(substr($BINlastmod_date, 11, 5)); + $lastmod_timeH = bindec(substr($BINlastmod_time, 0, 5)); + $lastmod_timeM = bindec(substr($BINlastmod_time, 5, 6)); + $lastmod_timeS = bindec(substr($BINlastmod_time, 11, 5)); + + $this->centralDirList[$dir['file_name']] = Array( + 'version_madeby'=>$dir['version_madeby'][1], + 'version_needed'=>$dir['version_needed'][1], + 'general_bit_flag'=>str_pad(decbin($file['general_bit_flag'][1]), 8, '0', STR_PAD_LEFT), + 'compression_method'=>$dir['compression_method'][1], + 'lastmod_datetime' =>mktime($lastmod_timeH, $lastmod_timeM, $lastmod_timeS, $lastmod_dateM, $lastmod_dateD, $lastmod_dateY), + 'crc-32' =>str_pad(dechex(ord($file['crc-32'][3])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][2])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][1])), 2, '0', STR_PAD_LEFT). + str_pad(dechex(ord($file['crc-32'][0])), 2, '0', STR_PAD_LEFT), + 'compressed_size'=>$dir['compressed_size'][1], + 'uncompressed_size'=>$dir['uncompressed_size'][1], + 'disk_number_start'=>$dir['disk_number_start'][1], + 'internal_attributes'=>$dir['internal_attributes'][1], + 'external_attributes1'=>$dir['external_attributes1'][1], + 'external_attributes2'=>$dir['external_attributes2'][1], + 'relative_offset'=>$dir['relative_offset'][1], + 'file_name'=>$dir['file_name'], + 'extra_field'=>$dir['extra_field'], + 'file_comment'=>$dir['file_comment'], + ); + } + + elseif($signature == $this->dirSignatureE){ + # $this->debugMsg(1, "EOF Dir Signature!"); + + $eodir['disk_number_this'] = unpack("v", fread($fh, 2)); // number of this disk + $eodir['disk_number'] = unpack("v", fread($fh, 2)); // number of the disk with the start of the central directory + $eodir['total_entries_this'] = unpack("v", fread($fh, 2)); // total number of entries in the central dir on this disk + $eodir['total_entries'] = unpack("v", fread($fh, 2)); // total number of entries in + $eodir['size_of_cd'] = unpack("V", fread($fh, 4)); // size of the central directory + $eodir['offset_start_cd'] = unpack("V", fread($fh, 4)); // offset of start of central directory with respect to the starting disk number + $zipFileCommentLenght = unpack("v", fread($fh, 2)); // zipfile comment length + $eodir['zipfile_comment'] = $zipFileCommentLenght[1]?fread($fh, $zipFileCommentLenght[1]):''; // zipfile comment + $this->endOfCentral = Array( + 'disk_number_this'=>$eodir['disk_number_this'][1], + 'disk_number'=>$eodir['disk_number'][1], + 'total_entries_this'=>$eodir['total_entries_this'][1], + 'total_entries'=>$eodir['total_entries'][1], + 'size_of_cd'=>$eodir['size_of_cd'][1], + 'offset_start_cd'=>$eodir['offset_start_cd'][1], + 'zipfile_comment'=>$eodir['zipfile_comment'], + ); + } + else{ + if(!$ddTry){ + $this->debugMsg(1, "Unexpected header. Trying to detect wrong placed 'Data Descriptor'...\n"); + $ddTry = true; + fseek($fh, 12-4, SEEK_CUR); // Jump over 'crc-32'(4) 'compressed-size'(4), 'uncompressed-size'(4) + continue; + } + $this->debugMsg(1, "Unexpected header, ending loop at offset ".ftell($fh)); + break; + } + $ddTry = false; + } + + if($this->debug){ + #------- Debug compressedList + $kkk = 0; + echo "<table border='0' style='font: 11px Verdana; border: 1px solid #000'>"; + foreach($this->compressedList as $fileName=>$item){ + if(!$kkk && $kkk=1){ + echo "<tr style='background: #ADA'>"; + foreach($item as $fieldName=>$value) + echo "<td>$fieldName</td>"; + echo '</tr>'; + } + echo "<tr style='background: #CFC'>"; + foreach($item as $fieldName=>$value){ + if($fieldName == 'lastmod_datetime') + echo "<td title='$fieldName' nowrap='nowrap'>".date("d/m/Y H:i:s", $value)."</td>"; + else + echo "<td title='$fieldName' nowrap='nowrap'>$value</td>"; + } + echo "</tr>"; + } + echo "</table>"; + + #------- Debug centralDirList + $kkk = 0; + if(sizeof($this->centralDirList)){ + echo "<table border='0' style='font: 11px Verdana; border: 1px solid #000'>"; + foreach($this->centralDirList as $fileName=>$item){ + if(!$kkk && $kkk=1){ + echo "<tr style='background: #AAD'>"; + foreach($item as $fieldName=>$value) + echo "<td>$fieldName</td>"; + echo '</tr>'; + } + echo "<tr style='background: #CCF'>"; + foreach($item as $fieldName=>$value){ + if($fieldName == 'lastmod_datetime') + echo "<td title='$fieldName' nowrap='nowrap'>".date("d/m/Y H:i:s", $value)."</td>"; + else + echo "<td title='$fieldName' nowrap='nowrap'>$value</td>"; + } + echo "</tr>"; + } + echo "</table>"; + } + + #------- Debug endOfCentral + $kkk = 0; + if(sizeof($this->endOfCentral)){ + echo "<table border='0' style='font: 11px Verdana' style='border: 1px solid #000'>"; + echo "<tr style='background: #DAA'><td colspan='2'>dUnzip - End of file</td></tr>"; + foreach($this->endOfCentral as $field=>$value){ + echo "<tr>"; + echo "<td style='background: #FCC'>$field</td>"; + echo "<td style='background: #FDD'>$value</td>"; + echo "</tr>"; + } + echo "</table>"; + } + } + + return $this->compressedList; + } + + + Function getExtraInfo($compressedFileName) + { + return + isset($this->centralDirList[$compressedFileName])? + $this->centralDirList[$compressedFileName]: + false; + } + + + Function getZipInfo($detail=false) + { + return $detail? + $this->endOfCentral[$detail]: + $this->endOfCentral; + } + + + Function unzip($compressedFileName, $targetFileName=false){ + $fdetails = &$this->compressedList[$compressedFileName]; + + if(!sizeof($this->compressedList)){ + $this->debugMsg(1, "Trying to unzip before loading file list... Loading it!"); + $this->getList(false, $compressedFileName); + } + if(!isset($this->compressedList[$compressedFileName])){ + $this->debugMsg(2, "File '<b>$compressedFileName</b>' is not compressed in the zip."); + return false; + } + if(substr($compressedFileName, -1) == "/"){ + $this->debugMsg(2, "Trying to unzip a folder name '<b>$compressedFileName</b>'."); + return false; + } + if(!$fdetails['uncompressed_size']){ + $this->debugMsg(1, "File '<b>$compressedFileName</b>' is empty."); + return ""; + } + + fseek($this->fh, $fdetails['contents-startOffset']); + return $this->uncompress( + fread($this->fh, $fdetails['compressed_size']), + $fdetails['compression_method'], + $fdetails['uncompressed_size'] ); + } + + + Function unzipAll($targetDir=false, $baseDir="", $maintainStructure=true, $chmod=false){ + if($targetDir === false) + $targetDir = dirname(__FILE__)."/"; + + $lista = $this->getList(); + if(sizeof($lista)) foreach($lista as $fileName=>$trash){ + $dirname = dirname($fileName); + $outDN = "$targetDir/$dirname"; + + if(substr($dirname, 0, strlen($baseDir)) != $baseDir) + continue; + + if(!is_dir($outDN) && $maintainStructure){ + $str = ""; + $folders = explode("/", $dirname); + foreach($folders as $folder){ + $str = $str?"$str/$folder":$folder; + if(!is_dir("$targetDir/$str")){ + $this->debugMsg(1, "Creating folder: $targetDir/$str"); + mkdir("$targetDir/$str"); + if($chmod) + chmod("$targetDir/$str", $chmod); + } + } + } + if(substr($fileName, -1, 1) == "/") + continue; + + $maintainStructure? + $this->unzip($fileName, "$targetDir/$fileName"): + $this->unzip($fileName, "$targetDir/".basename($fileName)); + + if($chmod) + chmod($maintainStructure?"$targetDir/$fileName":"$targetDir/".basename($fileName), $chmod); + } + } + + Function close(){ // Free the file resource + if($this->fh) + fclose($this->fh); + } + + // Private (you should NOT call these methods): + Function uncompress($content, $mode, $uncompressedSize, $targetFileName=false){ + switch($mode){ + case 0: + // Not compressed + return $content; + case 1: + $this->debugMsg(2, "Shrunk mode is not supported... yet?"); + return false; + case 2: + case 3: + case 4: + case 5: + $this->debugMsg(2, "Compression factor ".($mode-1)." is not supported... yet?"); + return false; + case 6: + $this->debugMsg(2, "Implode is not supported... yet?"); + return false; + case 7: + $this->debugMsg(2, "Tokenizing compression algorithm is not supported... yet?"); + return false; + case 8: + // Deflate + return gzinflate($content, $uncompressedSize); + case 9: + $this->debugMsg(2, "Enhanced Deflating is not supported... yet?"); + return false; + case 10: + $this->debugMsg(2, "PKWARE Date Compression Library Impoloding is not supported... yet?"); + return false; + default: + $this->debugMsg(2, "Unknown uncompress method: $mode"); + return false; + } + } + + + Function debugMsg($level, $string){ + if($this->debug) + if($level == 1) + echo "<b style='color: #777'>dUnzip2:</b> $string<br>"; + if($level == 2) + echo "<b style='color: #F00'>dUnzip2:</b> $string<br>"; + } +} +?>+ \ No newline at end of file diff --git a/modules/util/ArchiveZip.class.php b/modules/util/ArchiveZip.class.php @@ -0,0 +1,89 @@ +<?php + + +/** + * This source is taken from http://www.zend.com/zend/spotlight/creating-zip-files1.php + * Thank you! + */ +class ArchiveZip +{ + var $datasec = array(); + var $ctrl_dir = array(); + var $eof_ctrl_dir = "\x50\x4b\x05\x06\x00\x00\x00\x00"; + var $old_offset = 0; + + + function add_file($data, $name) + { + $name = str_replace("\\", "/", $name); + $unc_len = strlen($data); + $crc = crc32($data); + $zdata = gzcompress($data); + $zdate = substr ($zdata, 2, -4); + $c_len = strlen($zdata); + + + + $fr = "\x50\x4b\x03\x04"; + $fr .= "\x14\x00"; + $fr .= "\x00\x00"; + $fr .= "\x08\x00"; + $fr .= "\x00\x00\x00\x00"; + $fr .= pack("V",$crc); + $fr .= pack("V",$c_len); + $fr .= pack("V",$unc_len); + $fr .= pack("v", strlen($name) ); + $fr .= pack("v", 0 ); + $fr .= $name; + $fr .= $zdata; + $fr .= pack("V",$crc); + $fr .= pack("V",$c_len); + $fr .= pack("V",$unc_len); + + $this -> datasec[] = $fr; + + + + $new_offset = strlen(implode("", $this->datasec)); + + $cdrec = "\x50\x4b\x01\x02"; + $cdrec .="\x00\x00"; + $cdrec .="\x14\x00"; + $cdrec .="\x00\x00"; + $cdrec .="\x08\x00"; + $cdrec .="\x00\x00\x00\x00"; + $cdrec .= pack("V",$crc); + $cdrec .= pack("V",$c_len); + $cdrec .= pack("V",$unc_len); + $cdrec .= pack("v", strlen($name) ); + $cdrec .= pack("v", 0 ); + $cdrec .= pack("v", 0 ); + $cdrec .= pack("v", 0 ); + $cdrec .= pack("v", 0 ); + $cdrec .= pack("V", 32 ); + $cdrec .= pack("V", $this -> old_offset ); + + $this -> old_offset = $new_offset; + + $cdrec .= $name; + $this -> ctrl_dir[] = $cdrec; + } + + + function file() { + $data = implode("", $this -> datasec); + $ctrldir = implode("", $this -> ctrl_dir); + + return + $data. + $ctrldir. + $this -> eof_ctrl_dir. + pack("v", sizeof($this -> ctrl_dir)). + pack("v", sizeof($this -> ctrl_dir)). + pack("V", strlen($ctrldir)). + pack("V", strlen($data)). + "\x00\x00"; + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/Code.class.php b/modules/util/Code.class.php @@ -0,0 +1,44 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +/** + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class Code extends Macro +{ + var $code = ''; + + function execute() + { + if ( substr($this->code,0,5) != '<?php' ) + $this->code = "<?php\n".$this->code."\n?>"; + + $tmp = FileUtils::getTempDir().'/openratMacro'; + $tmp .= '.code.php.tmp'; + + $f = fopen( $tmp,'w' ); + fwrite( $f,$this->code ); + fclose( $f ); + + require( $tmp ); // Ausfuehren des temporaeren PHP-Codes + + unlink( $tmp ); + } +}+ \ No newline at end of file diff --git a/modules/util/Dynamic.class.php b/modules/util/Dynamic.class.php @@ -0,0 +1,34 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2013 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Oberklasse für dynamische Klassen ("Makros"). + * + * Diese Klasse dient nur der Abwärtskompabilität. Neue dynamische Klassen + * (ab jetzt "Makros") sollten von der Klasse Macro erben. + * + * @author Jan Dankert + * @package openrat.services + */ +class Dynamic extends Macro +{ + // Keine weitere Implementierung +} + +?>+ \ No newline at end of file diff --git a/modules/util/FileUtils.class.php b/modules/util/FileUtils.class.php @@ -0,0 +1,102 @@ +<?php + +/** + * Werkzeugklasse f�r Datei-Operationen. + * + */ +class FileUtils +{ + /** + * Fuegt einen Slash ("/") an das Ende an, sofern nicht bereits vorhanden. + * + * @param String $pfad + * @return Pfad mit angeh�ngtem Slash. + */ + public static function slashify($pfad) + { + if ( substr($pfad,-1,1) == '/') + return $pfad; + else + return $pfad.'/'; + } + + + + /** + * Liefert einen Verzeichnisnamen fuer temporaere Dateien. + */ + public static function createTempFile() + { + global $conf; + $tmpdir = @$conf['cache']['tmp_dir']; + $tmpfile = @tempnam( $tmpdir,'openrat_tmp' ); + + // 2. Versuch: Temp-Dir aus "upload_tmp_dir". + if ( $tmpfile === FALSE ) + { + $tmpdir = ini_get('upload_tmp_dir'); + $tmpfile = @tempnam( $tmpdir,'openrat_tmp' ); + } + + elseif ( $tmpfile === FALSE ) + { + $tmpfile = @tempnam( '','openrat_tmp' ); + } + + return $tmpfile; + } + + + /** + * Liefert einen Verzeichnisnamen fuer temporaere Dateien. + */ + public static function getTempDir() + { + $tmpfile = FileUtils::createTempFile(); + + $tmpdir = dirname($tmpfile); + @unlink($tmpfile); + + return FileUtils::slashify( $tmpdir ); + } + + + + /** + * Liest die Dateien aus dem angegebenen Ordner in ein Array. + * + * @param $dir Verzeichnis, welches gelesen werden soll + * @return Array Liste der Dateien im Ordner + */ + public static function readDir($dir) + { + $dir = FileUtils::slashify($dir); + $dateien = array(); + + if ( !is_dir($dir) ) + { + return false; + } + + if ( $dh = opendir($dir) ) + { + while( ($verzEintrag = readdir($dh)) !== false ) + { + if ( substr($verzEintrag,0,1) != '.' ) + { + $dateien[] = $verzEintrag; + } + } + closedir($dh); + + return $dateien; + } + else + { + die('unable to open directory: '.$dir); + } + + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/Ftp.class.php b/modules/util/Ftp.class.php @@ -0,0 +1,246 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Darstellen einer FTP-Verbindung, das beinhaltet + * das Login, das Kopieren von Dateien sowie praktische + * FTP-Funktionen + * + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class Ftp +{ + var $verb; + var $url; + var $log = array(); + + var $passive = false; + + var $ok = true; + + private $path; + + + // Konstruktor + function __construct( $url ) + { + $this->connect( $url ); + } + + + // Aufbauen der Verbindung + function connect( $url ) + { + $this->url = $url; + + global $conf; + + $conf_ftp = $conf['publish']['ftp']; + $ftp = parse_url( $this->url ); + + // Die projektspezifischen Werte gewinnen bei �berschneidungen mit den Default-Werten + $ftp = array_merge($conf_ftp,$ftp); + + // Nur FTP und FTPS (seit PHP 4.3) erlaubt + if ( !in_array(@$ftp['scheme'],array('ftp','ftps')) ) + { + $this->log[] = 'Unknown scheme in FTP Url: '.@$ftp['scheme']; + $this->log[] = 'Only FTP (and FTPS, if compiled in) are supported'; + $this->ok = false; + return; + } + + if ( function_exists('ftp_ssl_connect') && $ftp['scheme'] == 'ftps' ) + $this->verb = @ftp_ssl_connect( $ftp['host'],$ftp['port'] ); + else + $this->verb = @ftp_connect( $ftp['host'],$ftp['port'] ); + + if ( !$this->verb ) + { + $this->log[] = 'Cannot connect to '.$ftp['scheme'].'-server: '.$ftp['host'].':'.$ftp['port']; + $this->ok = false; + + Logger::error('Cannot connect to '.$ftp['host'].':'.$ftp['port']); + return; + } + + $this->log[] = 'Connected to FTP server '.$ftp['host'].':'.$ftp['port']; + + if ( empty($ftp['user']) ) + { + $ftp['user'] = 'anonymous'; + $ftp['pass'] = 'openrat@openrat.de'; + } + + if ( ! ftp_login( $this->verb,$ftp['user'],$ftp['pass'] ) ) + { + $this->log[] = 'Unable to login as user '.$ftp['user']; + $this->ok = false; + return; + } + + $this->log[] = 'Logged in as user '.$ftp['user']; + + $pasv = (!empty($ftp['fragment']) && $ftp['fragment'] == 'passive' ); + + $this->log[] = 'entering passive mode '.($pasv?'on':'off'); + if ( ! ftp_pasv($this->verb,true) ) + { + $this->log[] = 'cannot switch PASV mode'; + $this->ok = false; + return; + } + + if ( !empty($ftp['query']) ) + { + parse_str( $ftp['query'],$ftp_var ); + + if ( isset( $ftp_var['site'] ) ) + { + $site_commands = explode( ',',$ftp_var['site'] ); + foreach( $site_commands as $cmd ) + { + $this->log .= 'executing SITE command: '.$cmd; + + if ( ! @ftp_site( $this->verb,$cmd ) ) + { + $this->log[] = 'unable to do SITE command: '.$cmd; + $this->ok = false; + return; + } + } + } + } + + $this->path = rtrim( $ftp['path'],'/' ); + + $this->log[] = 'Changing directory to '.$this->path; + + if ( ! @ftp_chdir( $this->verb,$this->path ) ) + { + $this->log[] = 'unable CHDIR to directory: '.$this->path; + $this->ok = false; + return; + } + } + + + /** + * Kopieren einer Datei vom lokalen System auf den FTP-Server. + * + * @param String Quelle + * @param String Ziel + * @param int FTP-Mode (BINARY oder ASCII) + */ + function put( $source,$dest ) + { + if ( ! $this->ok ) + return; + + $ftp = parse_url( $this->url ); + + $dest = $this->path.'/'.$dest; + + $this->log .= "Copying file: $source -&gt; $dest ...\n"; + + $mode = FTP_BINARY; + $p = strrpos( basename($dest),'.' ); // Letzten Punkt suchen + + if ($p!==false) // Wennn letzten Punkt gefunden, dann dort aufteilen + { + $extension = substr( basename($dest),$p+1 ); + $type = config('mime-types',$extension); + if ( substr($type,0,5) == 'text/') + $mode = FTP_ASCII; + } + + Logger::debug("FTP PUT target:$dest mode:".(($mode==FTP_ASCII)?'ascii':'binary')); + + if ( !@ftp_put( $this->verb,$dest,$source,$mode ) ) + { + if ( !$this->mkdirs( dirname($dest) ) ) + return; // Fehler. + + ftp_chdir( $this->verb,$this->path ); + + if ( ! @ftp_put( $this->verb,$dest,$source,$mode ) ) + { + $this->ok = false; + $this->log[] = 'FTP PUT failed...'; + $this->log[] = 'source : '.$source; + $this->log[] = 'destination: '.$dest; + return; + } + + } + } + + + + /** + * Private Methode zum rekursiven Anlegen von Verzeichnissen. + * + * @param String Pfad + * @return boolean true, wenn ok + */ + function mkdirs( $strPath ) + { + if ( @ftp_chdir($this->verb,$strPath) ) + return true; // Verzeichnis existiert schon :) + + $pStrPath = dirname($strPath); + + if ( !$this->mkdirs($pStrPath) ) + return false; + + if ( ! @ftp_mkdir($this->verb,$strPath) ) + { + $this->ok = false; + $this->log[] = "failed to create remote directory: $strPath"; + } + + return $this->ok; + } + + + + /** + * Schlie�en der FTP-Verbindung.<br> + * Sollte unbedingt aufgerufen werden, damit keine unn�tigen Sockets aufbleiben. + */ + function close() + { + if ( !$this->ok ) // Noch alles ok? + return; + + if ( ! @ftp_quit( $this->verb ) ) + { + // Das Schlie�en der Verbindung hat nicht funktioniert. + // Eigentlich k�nnten wir das ignorieren, aber wir sind anst�ndig und melden eine Fehler. + $this->log[] = 'failed to close connection'; + $this->ok = false; + return; + } + } +} + + +?>+ \ No newline at end of file diff --git a/modules/util/GlobalFunctions.class.php b/modules/util/GlobalFunctions.class.php @@ -0,0 +1,71 @@ +<?php + +/** + * Bereitstellen von globalen Funktionen + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class GlobalFunctions +{ + public static function getIsoCodes() + { + global $conf_php; + + $iso = parse_ini_file( './language/lang.ini.'.$conf_php ); + asort( $iso ); + return $iso; + } + + + public static function lang( $text ) + { + global $SESS; + $text = strtoupper($text); + + if ( isset( $SESS['lang'][$text] ) ) + { + return $SESS['lang'][$text]; + } + else + { + return( '?'.$text.'?' ); + } + } + + + # Spracheinstellungen laden + + public static function language_from_http() + { + global $SESS, + $HTTP_SERVER_VARS, + $conf_php, + $conf; + + $languages = $HTTP_SERVER_VARS['HTTP_ACCEPT_LANGUAGE']; + $languages = explode(',',$languages); + foreach( $languages as $l ) + { + $l = substr($l,0,2); + if ( file_exists("./language/$l.ini.$conf_php") ) + return( $l ); + } + + // Keine passende Sprache im HTTP-Header gefunden + return $conf['global']['default_language']; + } + + + public static function language_read( $l='' ) + { + global $SESS, + $HTTP_SERVER_VARS, + $conf_php; + + $l = language_from_http(); + $SESS['lang'] = parse_ini_file( "./language/$l.ini.$conf_php" ); + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/Html.class.php b/modules/util/Html.class.php @@ -0,0 +1,178 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Bereitstellen von Methoden fuer die Darstellung von HTML-Elementen + * + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class Html +{ + public static function error( $field ) + { + global $inputErrors; + + if ( isset($inputErrors[$field]) ) + return '<span class="error">'.lang($inputErrors[$field]).'</span'; + } + + + + /** + * Ausgabe eines Variablenwertes.<br> + */ + public static function debug( $wert, $text='' ) + { + echo "<strong>DEBUG: $text (".gettype($wert).")</strong><br/>"; + echo "<pre>"; + print_r($wert); + echo "</pre>"; + } + + + /** + * Erzeugt eine relative Url innerhalb von Openrat + * + * @param string Aktion, die aufgerufen werden soll + * @param string Unteraktion, die innerhalb der Aktion aufgerufen werden soll + * @param int Id fuer diesen Aufruf + * @param array Weitere beliebige Parameter + */ + public static function url( $action,$subaction='',$id='',$params=array() ) + { + if ( intval($id)==0 ) + $id='-'; + + global $conf; + + if ( is_array($action) ) + { + $params = $action; + + if ( isset($params['callAction']) ) + { + $params['subaction'] = $params['callAction']; + unset( $params['callAction'] ); + unset( $params['callSubaction'] ); + } + + + if ( !isset($params['action' ])) $params['action' ] = ''; + if ( !isset($params['subaction'])) $params['subaction'] = ''; + if ( !isset($params['id' ])) $params['id' ] = ''; + $action = $params['action' ]; + $subaction = $params['subaction']; + $id = $params['id' ]; + unset( $params['action' ] ); + unset( $params['subaction'] ); + unset( $params['id' ] ); + $params['old']='true'; + } + + // Session-Id ergaenzen + if ( $conf['interface']['url']['add_sessionid'] ) + $params[ session_name() ] = session_id(); + + if ( config('security','use_post_token') ) + $params[ 'token'] = token(); + + $fake_urls = $conf['interface']['url']['fake_url' ]; + $url_format = $conf['interface']['url']['url_format']; + + if ( isset($params['objectid']) && !isset($params['id']) ) + $params['id'] = $params['objectid']; + + if ( $fake_urls ) + { +// if ( $id != '' ) +// $id = '.'.$id; + } + else + { + global $view; + $params[REQ_PARAM_ACTION ] = $action; + $params[REQ_PARAM_SUBACTION] = $subaction; + $params[REQ_PARAM_ID ] = $id; + + if ( !isset($params[REQ_PARAM_TARGET])) + $params[REQ_PARAM_TARGET ] = $view; + } + + if ( count($params) > 0 ) + { + $urlParameterList = array(); + foreach( $params as $var=>$value ) + { + $urlParameterList[] = urlencode($var).'='.urlencode($value); + } + $urlParameter = '?'.implode('&amp;',$urlParameterList); + } + else + { + $urlParameter = ''; + } + + if ( @$conf['interface']['url']['index'] ) + $controller_file_name = ''; + else + $controller_file_name = OR_CONTROLLER_FILE.'.'.PHP_EXT; + + $prefix = './'; + + if ( $fake_urls ) + $src = sprintf( $url_format,$action,$subaction,$id,session_id() ).$urlParameter; + else + $src = $prefix.$controller_file_name.$urlParameter; + + return $src; + } + + + + public static function complete_tag($tagname,$attributes) + { + $text = '<'.$tagname; + foreach( $attributes as $attribute_name=>$attribute_value ) + if ( !empty($attribute_value) ) + $text .= ' '.$attribute_name.'="'.$attribute_value.'"'; + $text .= ' />'; + return $text; + } + + + + public static function open_tag($tagname,$attributes) + { + $text = '<'.$tagname; + foreach( $attributes as $attribute_name=>$attribute_value ) + if ( !empty($attribute_value) ) + $text .= ' '.$attribute_name.'="'.$attribute_value.'"'; + $text .= '>'; + return $text; + } + + + public static function close_tag($tagname) + { + return '</'.$tagname.'>'; + } +} +?>+ \ No newline at end of file diff --git a/modules/util/Http.class.php b/modules/util/Http.class.php @@ -0,0 +1,610 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + + +/** + * Kapselung einer HTTP-Anfrage.<br> + * Unter Beruecksichtigung von RFC 1945.<br> + * + * @author Jan Dankert + * @package openrat.services + */ +class Http +{ + public $header = array(); + + public $url = array(); + public $responseHeader = array(); + public $requestParameter = array(); + public $urlParameter = array(); + + /** + * HTTP-Request-Typ.<br> + * Muss entweder "GET" oder "POST" sein.<br> + * Default: "GET". + * + * @var String Request-Typ + */ + public $method = 'GET'; + public $error = ''; + public $status = ''; + public $body = ''; + + public $httpCmd = ''; + + + + /** + * Erzeugt eine HTTP-Anfrage. + * + * @param String URL + * @return Http + */ + public function Http( $url = '' ) + { + $this->setURL( $url ); + $this->header['User-Agent'] = 'Mozilla/5.0 (OpenRat CMS)'; + $this->header['Connection'] = 'close'; + } + + + + /** + * Setzt die URL. + * + * @param String URL + */ + function setURL( $url ) + { + $this->url = parse_url($url); + + if ( empty($this->url['host']) && !empty($this->url['path']) ) + { + $this->url['host'] = basename($this->url['path']); + $this->url['path'] = '/'; + } + + if ( empty($this->url['path']) ) + $this->url['path'] = '/'; + + if ( !isset($this->url['port']) ) + if ( !isset($this->url['scheme']) ) + { + $this->url['scheme'] = 'http'; // Standard-Port. + $this->url['port'] = 80; // Standard-Port. + } + elseif ( $this->url['scheme'] == 'https' ) + $this->url['port'] = 443; // SSL-Port. + else + $this->url['port'] = 80; // Standard-Port. + + if ( !empty($this->url['query']) ) + parse_str( $this->url['query'],$this->urlParameter ); + + } + + + + /** + * Setzt Authentisierungsinformationen in den HTTP-Request.<br> + * + * @param String Benutzername + * @param String Kennwort + */ + public function setBasicAuthentication( $user, $password ) + { + $this->header['Authorization'] = 'Basic '.base64_encode($user.':'.$password); + } + + + + /** + * Erzeugt eine HTTP-Parameterstring mit allen Parametern. + * + * @param withPraefixQuestionMark Praefix mit Fragezeichen (fuer GET-Anfragen) + * @return String URL-Parameter + */ + public function getParameterString( $withPraefixQuestionMark=false ) + { + $parameterString = ''; + $parameter = $this->urlParameter + $this->requestParameter; + + if ( ! empty($parameter) ) + { + foreach( $this->requestParameter as $paramName => $paramValue ) + { + if ( strlen($parameterString) > 0) + $parameterString .= '&'; + elseif ( $withPraefixQuestionMark ) + $parameterString .= '?'; + + $parameterString .= urlencode($paramName) . '=' .urlencode($paramValue); + } + } + + return $parameterString; + } + + + /** + * Liefert die URL des Requests. + * + * @return String URL + */ + public function getUrl() + { + $location = $this->url['scheme']; + $location .= '://'; + $location .= $this->url['host']; + if ( $this->url['scheme'] == 'http' && $this->url['port'] != 80 || + $this->url['scheme'] == 'https' && $this->url['port'] != 443 ) + $location .= ':'.$this->url['port']; + $location .= $this->url['path']; + + $location .= $this->getParameterString(true); + + if ( isset($this->url['fragment']) ) + $location .= '#'.$this->url['fragment']; + + return $location; + } + + + /** + * Sendet eine Redirect-Anweisung mit der aktuellen URL an den Browser. + */ + public function sendRedirect() + { + $location = $this->getUrl(); + + header('Location: '.$location); + exit; + } + + + /** + * Führt einen HTTP-Request durch. + * + * @return boolean Erfolg der Anfrage. + */ + public function request() + { + $this->error = ''; + $this->status = ''; + + $errno = 0; + $errstr = ''; + + if ( empty($this->url['host']) ) + { + $this->error = "No hostname specified"; + return false; + } + + foreach( $this->header as $header_key=>$header_value ) + { + if ( is_numeric( $header_key ) ) + { + $dp = strpos($header_value,':'); + if ( $dp!==FALSE) + $this->header[substr($header_value,0,$dp)] = substr($header_value,$dp+1); + unset($this->header[$header_key]); + } + } + + $parameterString = $this->getParameterString(); + + if ( $this->method == 'POST' ) + { + $this->header['Content-Type' ] = 'application/x-www-form-urlencoded'; + $this->header['Content-Length'] = strlen($parameterString); + } + + // Accept-Header setzen, falls noch nicht vorhanden. + if ( !array_key_exists('Accept',$this->header) ) + $this->header['Accept'] = '*/*'; + + $this->responseHeader = array(); + + // RFC 1945 (Section 9.3) says: + // A user agent should never automatically redirect a request + // more than 5 times, since such redirections usually indicate an infinite loop. + for( $r=1; $r<=5; $r++ ) + { + $this->header['Host'] = $this->url['host']; + + // Die Funktion fsockopen() erwartet eine Protokollangabe (bei TCP optional, bei SSL notwendig). + if ( $this->url['scheme'] == 'https' || $this->url['port'] == '443' ) + $prx_proto = 'ssl://'; // SSL + else + $prx_proto = 'tcp://'; // Default + + $fp = @fsockopen ($prx_proto.$this->url['host'],$this->url['port'], $errno, $errstr, 30); + + if ( !$fp || !is_resource($fp) ) + { + // Keine Verbindung zum Host moeglich. + $this->error = "Connection refused: '".$prx_proto.$this->url['host'].':'.$this->url['port']." - $errstr ($errno)"; + return false; + } + else + { + + $lb = "\r\n"; + $http_get = $this->url['path']; + + $request_header = array( $this->method.' '.$http_get.' HTTP/1.0'); + + foreach($this->header as $header_key=>$header_value) + $request_header[] = $header_key.': '.$header_value; + + $http_request = implode($lb,$request_header).$lb.$lb; + + if ( $this->method == 'GET') + if ( !empty($parameterString) ) + $http_get .= '?'.$parameterString; + + if ( $this->method == 'POST' ) + $http_request .= $parameterString; + + if (!is_resource($fp)) { + $this->error = 'Connection lost after connect: '.$prx_proto.$this->url['host'].':'.$this->url['port']; + return false; + } + fputs($fp, $http_request); // Die HTTP-Anfrage zum Server senden. + + // Jetzt erfolgt das Auslesen der HTTP-Antwort. + $isHeader = true; + + // RFC 1945 (Section 6.1) schreibt als Statuszeile folgendes Format vor + // "HTTP/" 1*DIGIT "." 1*DIGIT SP 3DIGIT SP + if (!is_resource($fp)) { + $this->error = 'Connection lost during transfer: '.$this->url['host'].':'.$this->url['port']; + return false; + } + elseif (!feof($fp)) { + $line = fgets($fp,1028); + $this->status = substr($line,9,3); + } + else + { + $this->error = 'Unexpected EOF while reading HTTP-Response'; + return false; + } + + $this->body = ''; + while (!feof($fp)) { + $line = fgets($fp,1028); + if ( $isHeader && trim($line)=='' ) // Leerzeile nach Header. + { + $isHeader = false; + } + elseif( $isHeader ) + { + list($headerName,$headerValue) = explode(': ',$line) + array(1=>''); + $this->responseHeader[$headerName] = trim($headerValue); + } + else + { + $this->body .= $line; + } + } + fclose($fp); // Verbindung brav schlie�en. + + + // RFC 1945 (Section 6.1.1) schreibt + // "[...] However, applications must understand the class of any status code, as + // indicated by the first digit" + // Daher interessiert uns nur die erste Stelle des 3-stelligen HTTP-Status. + + // 301 Moved Permanently + // 302 Moved Temporarily + if ( $this->status == '301' || + $this->status == '302' ) + { + $location = @$this->responseHeader['Location']; + if ( empty($location) ) + { + $this->error = '301/302 Response without Location-header'; + return false; + } + + //Html::debug($this->url,"alte URL"); + //Html::debug($location,"NEUES REDIRECT AUF"); + $this->setURL($location); + continue; // Naechster Versuch mit umgeleiteter Adresse. + } + + // RFC 1945 (Section 6.1.1) schreibt + // "2xx: Success - The action was successfully received, understood, and accepted." + elseif ( substr($this->status,0,1) == '2' ) + { + return true; + } + elseif ( substr($this->status,0,1) == '4' ) + { + $this->error = 'Client Error: '.$this->status; + return false; + } + elseif ( substr($this->status,0,1) == '5' ) + { + $this->error = 'Server Error: '.$this->status; + return false; + } + else + { + $this->error = 'Unexpected HTTP-Status: '.$this->status. '; this is mostly a client error, sorry.'; + return false; + } + } + + $this->error = 'Too much redirects, infinite loop assumed. Exiting. Last URL: '.$http_get; + return false; + + } + + } + + + /** + * Aus dem HTTP-Header werden die vom Browser angeforderten Sprachen + * gelesen.<br> + * Es wird eine Liste von Sprachen erzeugt.<br> + * + * Beispiel: + * 'de_DE','de','en_GB','en' ... usw.<br> + * Wenn der Browser 'de_DE' anfordert, wird hier zusätzlich + * auch 'de' (als Fallback) ermittelt. + * + * @static + * @return Array + */ + public static function getLanguages() + { + global $HTTP_SERVER_VARS; + + $languages = array(); + $http_languages = @$HTTP_SERVER_VARS['HTTP_ACCEPT_LANGUAGE']; + foreach( explode(',',$http_languages) as $l ) + { + list($part) = explode(';',$l); // Priorit�ten ignorieren. + $languages[] = trim($part); + + // Aus "de_DE" das "de" extrahieren. + $languages[] = current(explode('_',str_replace('-','_',trim($part)))); + } + + return array_unique( $languages ); + } + + + /** + * Ermittelt die aktuelle HTTP-Adresse des Requests (inkl. Pfad, jedoch ohne Datei). + * + * @return String URL + */ + public static function getServer() + { + $https = getenv('HTTPS'); + + if ( $https ) + $server = 'https://'; + else + $server = 'http://'; + + $server .= getenv('SERVER_NAME').dirname(getenv('REQUEST_URI')); + + return $server; + } + + + + /** + * Server-Fehlermeldung anzeigen.<br> + * + * Erzeugt einen "HTTP 501 Internal Server Error". Zusaetzlich + * wird ein 'rollback' auf der Datenbank ausgefaehrt. + * + * @param String $message Eigener Hinweistext + */ + public static function serverError($message,$reason='') + { + if ( class_exists('Session')) + { + $db = Session::getDatabase(); + if ( is_object( $db ) ) + $db->rollback(); + } + + if ( class_exists('Logger')) + Logger::warn($message."\n".$reason); + + Http::sendStatus(501,'Internal Server Error',$message,$reason); + } + + + + /** + * Der Benutzer ist nicht autorisiert, eine Aktion auszufuehren. + * + * Diese Funktion erzeugt einen "HTTP 403 Not Authorized" und das + * Skript wird beendet. + * + * @param String $text Text + * @param String $message Eigener Hinweistext + */ + public static function notAuthorized($message='') + { + Logger::warn("Security warning: $message"); + Http::sendStatus(403,'Not authorized',$message); + } + + + + + + + /** + * Nichts gefunden. + * + * Diese Funktion erzeugt einen "HTTP 404 Not found" und das + * Skript wird beendet. + * + * @param String $text Text + * @param String $message Eigener Hinweistext + */ + public static function notFound($text,$message) + { + Http::sendStatus(404,'Not found',$message); + } + + + + /** + * Kein Inhalt. + * + * Die HTTP-Antwort stellt gegenüber dem Client klar, dass es keinen Inhalt gibt. + */ + public static function noContent() + { + header('HTTP/1.0 204 No Content'); + exit; + } + + + + /** + * Schickt einen HTTP-Status zum Client und beendet das Skript. + * + * @param Integer $status HTTP-Status (ganzzahlig) (Default: 501) + * @param String $text HTTP-Meldung (Default: 'Internal Server Error') + * @param String $message Eigener Hinweistext (Default: leer) + * @param String $reason Technischer Grund (Default: leer) + */ + public static function sendStatus( $status=501,$text='Internal Server Error',$message='',$reason='' ) + { + if ( headers_sent() ) + { + echo "$status $text\n$message"; + exit; + } + + header('HTTP/1.0 '.intval($status).' '.$text); + + + $types = Http::getAccept(); + + if ( @$_REQUEST['output']=='json' || sizeof($types)==1 && in_array('application/json',$types) ) + { + header('Content-Type: application/json'); + require_once( OR_SERVICECLASSES_DIR."JSON.class.".PHP_EXT ); + $json = new JSON(); + echo $json->encode( array('status'=>$status,'error'=>$text,'description'=>$message,'reason'=>$reason) ); + } + elseif ( @$_REQUEST['output']=='xml' || sizeof($types)==1 && in_array('application/xml',$types) ) + { + header('Content-Type: application/xml'); + require_once( OR_SERVICECLASSES_DIR."XML.class.".PHP_EXT ); + $xml = new XML(); + $xml->root='error'; + echo $xml->encode( array('status'=>$status,'error'=>$text,'description'=>$message,'reason'=>$reason) ); + } + else + { + header('Content-Type: text/html'); + $message = htmlentities($message); + $reason = htmlentities($reason ); + $signature = OR_TITLE.' '.OR_VERSION.' '.getenv('SERVER_SOFTWARE'); + echo <<<HTML +<html> +<head><title>$status $text - OpenRat</title></head> +<body> +<h1>$text</h1> +<p>$message</p> +<pre>$reason</pre> +<hr> +<address>$signature</adddress> +</body> +</html> +HTML; + } + exit; + } + + + /** + * Liefert den Mime-Type, den der Browser (oder besser: HTTP-Client) wünscht. + * + * @return Array Mime-Typen, welche vom User-Agent akzeptiert werden. + */ + public static function getAccept() + { + $httpAccept = getenv('HTTP_ACCEPT'); + return $types = explode(',',$httpAccept); + } + + + + /** + * Liefert die IPv4-Adresse des Clients. Falls der Request durch einen Proxy kam, wird + * versucht, die echte IP-Adresse aus dem Anfrageheader zu ermitteln. + * + * @return Client-IPv4-Adresse + */ + public static function getClientIP() + { + $ip = ''; + + if ( isset($_SERVER["HTTP_X_FORWARDED_FOR"]) ) + { + $ip = $_SERVER["HTTP_X_FORWARDED_FOR"]; + } + elseif ( isset($_SERVER["HTTP_CLIENT_IP"]) ) + { + $ip = $_SERVER["HTTP_CLIENT_IP"]; + } + elseif ( isset($_SERVER["REMOTE_ADDR"]) ) + { + $ip = $_SERVER["REMOTE_ADDR"]; + } + + return $ip; + } + + + + /** + * Ermittelt den TCP/IP-Port des Clients. + * Achtung, bei Proxy-Zugriffen kann dies der Port des Proxys sein. + * + * @return TCP/IP-Port + */ + public static function getClientPort() + { + $ip = ''; + + if ( isset($_SERVER["REMOTE_PORT"]) ) + { + $ip = $_SERVER["REMOTE_PORT"]; + } + + return $ip; + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/JSON.class.php b/modules/util/JSON.class.php @@ -0,0 +1,809 @@ +<?php +/** + * Converts to and from JSON format. + * + * JSON (JavaScript Object Notation) is a lightweight data-interchange + * format. It is easy for humans to read and write. It is easy for machines + * to parse and generate. It is based on a subset of the JavaScript + * Programming Language, Standard ECMA-262 3rd Edition - December 1999. + * This feature can also be found in Python. JSON is a text format that is + * completely language independent but uses conventions that are familiar + * to programmers of the C-family of languages, including C, C++, C#, Java, + * JavaScript, Perl, TCL, and many others. These properties make JSON an + * ideal data-interchange language. + * + * This package provides a simple encoder and decoder for JSON notation. It + * is intended for use with client-side Javascript applications that make + * use of HTTPRequest to perform server communication functions - data can + * be encoded into JSON notation for use in a client-side javascript, or + * decoded from incoming Javascript requests. JSON format is native to + * Javascript, and can be directly eval()'ed with no further parsing + * overhead + * + * All strings should be in ASCII or UTF-8 format! + * + * LICENSE: Redistribution and use in source and binary forms, with or + * without modification, are permitted provided that the following + * conditions are met: Redistributions of source code must retain the + * above copyright notice, this list of conditions and the following + * disclaimer. Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following disclaimer + * in the documentation and/or other materials provided with the + * distribution. + * + * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN + * NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR + * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE + * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH + * DAMAGE. + * + * @category + * @package Services_JSON + * @author Michal Migurski <mike-json@teczno.com> + * @author Matt Knapp <mdknapp[at]gmail[dot]com> + * @author Brett Stimmerman <brettstimmerman[at]gmail[dot]com> + * @author Jan Dankert + * @copyright 2005 Michal Migurski + * @version CVS: $Id$ + * @license http://www.opensource.org/licenses/bsd-license.php + * @link http://pear.php.net/pepr/pepr-proposal-show.php?id=198 + */ + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_INDENT', "\t"); + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_SLICE', 1); + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_IN_STR', 2); + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_IN_ARR', 3); + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_IN_OBJ', 4); + +/** + * Marker constant for Services_JSON::decode(), used to flag stack state + */ +define('SERVICES_JSON_IN_CMT', 5); + +/** + * Behavior switch for Services_JSON::decode() + */ +define('SERVICES_JSON_LOOSE_TYPE', 16); + +/** + * Behavior switch for Services_JSON::decode() + */ +define('SERVICES_JSON_SUPPRESS_ERRORS', 32); + +/** + * Converts to and from JSON format. + * + * Brief example of use: + * + * <code> + * // create a new instance of Services_JSON + * $json = new Services_JSON(); + * + * // convert a complexe value to JSON notation, and send it to the browser + * $value = array('foo', 'bar', array(1, 2, 'baz'), array(3, array(4))); + * $output = $json->encode($value); + * + * print($output); + * // prints: ["foo","bar",[1,2,"baz"],[3,[4]]] + * + * // accept incoming POST data, assumed to be in JSON notation + * $input = file_get_contents('php://input', 1000000); + * $value = $json->decode($input); + * </code> + */ +class JSON +{ + /** + * constructs a new JSON instance + * + * @param int $use object behavior flags; combine with boolean-OR + * + * possible values: + * - SERVICES_JSON_LOOSE_TYPE: loose typing. + * "{...}" syntax creates associative arrays + * instead of objects in decode(). + * - SERVICES_JSON_SUPPRESS_ERRORS: error suppression. + * Values which can't be encoded (e.g. resources) + * appear as NULL instead of throwing errors. + * By default, a deeply-nested resource will + * bubble up with an error, so all return values + * from encode() should be checked with isError() + */ + function Services_JSON() + { + $this->use = SERVICES_JSON_LOOSE_TYPE; + } + + /** + * convert a string from one UTF-16 char to one UTF-8 char + * + * Normally should be handled by mb_convert_encoding, but + * provides a slower PHP-only method for installations + * that lack the multibye string extension. + * + * @param string $utf16 UTF-16 character + * @return string UTF-8 character + * @access private + */ + function utf162utf8($utf16) + { + // oh please oh please oh please oh please oh please + if(function_exists('mb_convert_encoding')) { + return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16'); + } + + $bytes = (ord($utf16{0}) << 8) | ord($utf16{1}); + + switch(true) { + case ((0x7F & $bytes) == $bytes): + // this case should never be reached, because we are in ASCII range + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return chr(0x7F & $bytes); + + case (0x07FF & $bytes) == $bytes: + // return a 2-byte UTF-8 character + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return chr(0xC0 | (($bytes >> 6) & 0x1F)) + . chr(0x80 | ($bytes & 0x3F)); + + case (0xFFFF & $bytes) == $bytes: + // return a 3-byte UTF-8 character + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return chr(0xE0 | (($bytes >> 12) & 0x0F)) + . chr(0x80 | (($bytes >> 6) & 0x3F)) + . chr(0x80 | ($bytes & 0x3F)); + } + + // ignoring UTF-32 for now, sorry + return ''; + } + + /** + * convert a string from one UTF-8 char to one UTF-16 char + * + * Normally should be handled by mb_convert_encoding, but + * provides a slower PHP-only method for installations + * that lack the multibye string extension. + * + * @param string $utf8 UTF-8 character + * @return string UTF-16 character + * @access private + */ + function utf82utf16($utf8) + { + // oh please oh please oh please oh please oh please + if(function_exists('mb_convert_encoding')) { + return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8'); + } + + switch(strlen($utf8)) { + case 1: + // this case should never be reached, because we are in ASCII range + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return $utf8; + + case 2: + // return a UTF-16 character from a 2-byte UTF-8 char + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return chr(0x07 & (ord($utf8{0}) >> 2)) + . chr((0xC0 & (ord($utf8{0}) << 6)) + | (0x3F & ord($utf8{1}))); + + case 3: + // return a UTF-16 character from a 3-byte UTF-8 char + // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + return chr((0xF0 & (ord($utf8{0}) << 4)) + | (0x0F & (ord($utf8{1}) >> 2))) + . chr((0xC0 & (ord($utf8{1}) << 6)) + | (0x7F & ord($utf8{2}))); + } + + // ignoring UTF-32 for now, sorry + return ''; + } + + /** + * encodes an arbitrary variable into JSON format + * + * @param mixed $var any number, boolean, string, array, or object to be encoded. + * see argument 1 to Services_JSON() above for array-parsing behavior. + * if var is a strng, note that encode() always expects it + * to be in ASCII or UTF-8 format! + * + * @return mixed JSON string representation of input var or an error if a problem occurs + * @access public + */ + function encode($var) + { + static $indentNr = 0; + + $indent = str_repeat(SERVICES_JSON_INDENT,$indentNr); + + switch (gettype($var)) { + case 'boolean': + return $var ? 'true' : 'false'; + + case 'NULL': + return 'null'; + + case 'integer': + return (int) $var; + + case 'double': + case 'float': + return (float) $var; + + case 'string': + // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT + $ascii = ''; + $strlen_var = strlen($var); + + /* + * Iterate over every character in the string, + * escaping with a slash or encoding to UTF-8 where necessary + */ + for ($c = 0; $c < $strlen_var; ++$c) { + + $ord_var_c = ord($var{$c}); + + switch (true) { + case $ord_var_c == 0x08: + $ascii .= '\b'; + break; + case $ord_var_c == 0x09: + $ascii .= '\t'; + break; + case $ord_var_c == 0x0A: + $ascii .= '\n'; + break; + case $ord_var_c == 0x0C: + $ascii .= '\f'; + break; + case $ord_var_c == 0x0D: + $ascii .= '\r'; + break; + + case $ord_var_c == 0x22: + case $ord_var_c == 0x2F: + case $ord_var_c == 0x5C: + // double quote, slash, slosh + $ascii .= '\\'.$var{$c}; + break; + + case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)): + // characters U-00000000 - U-0000007F (same as ASCII) + $ascii .= $var{$c}; + break; + + case (($ord_var_c & 0xE0) == 0xC0): + // characters U-00000080 - U-000007FF, mask 110XXXXX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $char = pack('C*', $ord_var_c, ord($var{$c + 1})); + $c += 1; + $utf16 = $this->utf82utf16($char); + $ascii .= sprintf('\u%04s', bin2hex($utf16)); + break; + + case (($ord_var_c & 0xF0) == 0xE0): + // characters U-00000800 - U-0000FFFF, mask 1110XXXX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $char = pack('C*', $ord_var_c, + @ord($var{$c + 1}), + @ord($var{$c + 2})); + $c += 2; + $utf16 = $this->utf82utf16($char); + $ascii .= sprintf('\u%04s', bin2hex($utf16)); + break; + + case (($ord_var_c & 0xF8) == 0xF0): + // characters U-00010000 - U-001FFFFF, mask 11110XXX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $char = pack('C*', $ord_var_c, + @ord($var{$c + 1}), + @ord($var{$c + 2}), + @ord($var{$c + 3})); + $c += 3; + $utf16 = $this->utf82utf16($char); + $ascii .= sprintf('\u%04s', bin2hex($utf16)); + break; + + case (($ord_var_c & 0xFC) == 0xF8): + // characters U-00200000 - U-03FFFFFF, mask 111110XX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $char = pack('C*', $ord_var_c, + @ord($var{$c + 1}), + @ord($var{$c + 2}), + @ord($var{$c + 3}), + @ord($var{$c + 4})); + $c += 4; + $utf16 = $this->utf82utf16($char); + $ascii .= sprintf('\u%04s', bin2hex($utf16)); + break; + + case (($ord_var_c & 0xFE) == 0xFC): + // characters U-04000000 - U-7FFFFFFF, mask 1111110X + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $char = pack('C*', $ord_var_c, + @ord($var{$c + 1}), + @ord($var{$c + 2}), + @ord($var{$c + 3}), + @ord($var{$c + 4}), + @ord(@$var{$c + 5})); + $c += 5; + $utf16 = $this->utf82utf16($char); + $ascii .= sprintf('\u%04s', bin2hex($utf16)); + break; + } + } + + return '"'.$ascii.'"'; + + case 'array': + /* + * As per JSON spec if any array key is not an integer + * we must treat the the whole array as an object. We + * also try to catch a sparsely populated associative + * array with numeric keys here because some JS engines + * will create an array with empty indexes up to + * max_index which can cause memory issues and because + * the keys, which may be relevant, will be remapped + * otherwise. + * + * As per the ECMA and JSON specification an object may + * have any string as a property. Unfortunately due to + * a hole in the ECMA specification if the key is a + * ECMA reserved word or starts with a digit the + * parameter is only accessible using ECMAScript's + * bracket notation. + */ + + // treat as a JSON object + if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) { + $indentNr++; + $properties = array_map(array($this, 'name_value'), + array_keys($var), + array_values($var)); + $indentNr--; + + foreach($properties as $property) { + if(JSON::isError($property)) { + return $property; + } + } + + return "\n$indent".'{' ."\n$indent".SERVICES_JSON_INDENT. join(','."\n$indent".SERVICES_JSON_INDENT, $properties) ."\n$indent".'}'."\n$indent"; + } + + // treat it like a regular array + $indentNr++; + $elements = array_map(array($this, 'encode'), $var); + $indentNr--; + + foreach($elements as $element) { + if(JSON::isError($element)) { + return $element; + } + } + + return "\n$indent".'['."\n$indent".SERVICES_JSON_INDENT. join(','."\n$indent".SERVICES_JSON_INDENT, $elements) . "\n$indent".']'."\n$indent"; + + case 'object': + $vars = get_object_vars($var); + + $indentNr++; + $properties = array_map(array($this, 'name_value'), + array_keys($vars), + array_values($vars)); + $indentNr--; + + foreach($properties as $property) { + if(JSON::isError($property)) { + return $property; + } + } + + return "\n$indent".'{' ."\n$indent".SERVICES_JSON_INDENT. join(','."\n$indent".SERVICES_JSON_INDENT, $properties) . "\n$indent".'}'."\n$indent"; + + default: + return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS) + ? 'null' + : new JSON_Error(gettype($var)." can not be encoded as JSON string"); + } + } + + + + /** + * array-walking function for use in generating JSON-formatted name-value pairs + * + * @param string $name name of key to use + * @param mixed $value reference to an array element to be encoded + * + * @return string JSON-formatted name-value pair, like '"name":value' + * @access private + */ + function name_value($name, $value ) + { + $encoded_value = $this->encode($value); + + if(JSON::isError($encoded_value)) { + return $encoded_value; + } + + return $this->encode(strval($name)) . ':' . $encoded_value; + } + + /** + * reduce a string by removing leading and trailing comments and whitespace + * + * @param $str string string value to strip of comments and whitespace + * + * @return string string value stripped of comments and whitespace + * @access private + */ + function reduce_string($str) + { + $str = preg_replace(array( + + // eliminate single line comments in '// ...' form + '#^\s*//(.+)$#m', + + // eliminate multi-line comments in '/* ... */' form, at start of string + '#^\s*/\*(.+)\*/#Us', + + // eliminate multi-line comments in '/* ... */' form, at end of string + '#/\*(.+)\*/\s*$#Us' + + ), '', $str); + + // eliminate extraneous space + return trim($str); + } + + /** + * decodes a JSON string into appropriate variable + * + * @param string $str JSON-formatted string + * + * @return mixed number, boolean, string, array, or object + * corresponding to given JSON input string. + * See argument 1 to Services_JSON() above for object-output behavior. + * Note that decode() always returns strings + * in ASCII or UTF-8 format! + * @access public + */ + function decode($str) + { + $str = $this->reduce_string($str); + + switch (strtolower($str)) { + case 'true': + return true; + + case 'false': + return false; + + case 'null': + return null; + + default: + $m = array(); + + if (is_numeric($str)) { + // Lookie-loo, it's a number + + // This would work on its own, but I'm trying to be + // good about returning integers where appropriate: + // return (float)$str; + + // Return float or int, as appropriate + return ((float)$str == (integer)$str) + ? (integer)$str + : (float)$str; + + } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) { + // STRINGS RETURNED IN UTF-8 FORMAT + $delim = substr($str, 0, 1); + $chrs = substr($str, 1, -1); + $utf8 = ''; + $strlen_chrs = strlen($chrs); + + for ($c = 0; $c < $strlen_chrs; ++$c) { + + $substr_chrs_c_2 = substr($chrs, $c, 2); + $ord_chrs_c = ord($chrs{$c}); + + switch (true) { + case $substr_chrs_c_2 == '\b': + $utf8 .= chr(0x08); + ++$c; + break; + case $substr_chrs_c_2 == '\t': + $utf8 .= chr(0x09); + ++$c; + break; + case $substr_chrs_c_2 == '\n': + $utf8 .= chr(0x0A); + ++$c; + break; + case $substr_chrs_c_2 == '\f': + $utf8 .= chr(0x0C); + ++$c; + break; + case $substr_chrs_c_2 == '\r': + $utf8 .= chr(0x0D); + ++$c; + break; + + case $substr_chrs_c_2 == '\\"': + case $substr_chrs_c_2 == '\\\'': + case $substr_chrs_c_2 == '\\\\': + case $substr_chrs_c_2 == '\\/': + if (($delim == '"' && $substr_chrs_c_2 != '\\\'') || + ($delim == "'" && $substr_chrs_c_2 != '\\"')) { + $utf8 .= $chrs{++$c}; + } + break; + + case preg_match('/\\\u[0-9A-F]{4}/i', substr($chrs, $c, 6)): + // single, escaped unicode character + $utf16 = chr(hexdec(substr($chrs, ($c + 2), 2))) + . chr(hexdec(substr($chrs, ($c + 4), 2))); + $utf8 .= $this->utf162utf8($utf16); + $c += 5; + break; + + case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F): + $utf8 .= $chrs{$c}; + break; + + case ($ord_chrs_c & 0xE0) == 0xC0: + // characters U-00000080 - U-000007FF, mask 110XXXXX + //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $utf8 .= substr($chrs, $c, 2); + ++$c; + break; + + case ($ord_chrs_c & 0xF0) == 0xE0: + // characters U-00000800 - U-0000FFFF, mask 1110XXXX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $utf8 .= substr($chrs, $c, 3); + $c += 2; + break; + + case ($ord_chrs_c & 0xF8) == 0xF0: + // characters U-00010000 - U-001FFFFF, mask 11110XXX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $utf8 .= substr($chrs, $c, 4); + $c += 3; + break; + + case ($ord_chrs_c & 0xFC) == 0xF8: + // characters U-00200000 - U-03FFFFFF, mask 111110XX + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $utf8 .= substr($chrs, $c, 5); + $c += 4; + break; + + case ($ord_chrs_c & 0xFE) == 0xFC: + // characters U-04000000 - U-7FFFFFFF, mask 1111110X + // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8 + $utf8 .= substr($chrs, $c, 6); + $c += 5; + break; + + } + + } + + return $utf8; + + } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) { + // array, or object notation + + if ($str{0} == '[') { + $stk = array(SERVICES_JSON_IN_ARR); + $arr = array(); + } else { + if ($this->use & SERVICES_JSON_LOOSE_TYPE) { + $stk = array(SERVICES_JSON_IN_OBJ); + $obj = array(); + } else { + $stk = array(SERVICES_JSON_IN_OBJ); + $obj = new stdClass(); + } + } + + array_push($stk, array('what' => SERVICES_JSON_SLICE, + 'where' => 0, + 'delim' => false)); + + $chrs = substr($str, 1, -1); + $chrs = $this->reduce_string($chrs); + + if ($chrs == '') { + if (reset($stk) == SERVICES_JSON_IN_ARR) { + return $arr; + + } else { + return $obj; + + } + } + + //print("\nparsing {$chrs}\n"); + + $strlen_chrs = strlen($chrs); + + for ($c = 0; $c <= $strlen_chrs; ++$c) { + + $top = end($stk); + $substr_chrs_c_2 = substr($chrs, $c, 2); + + if (($c == $strlen_chrs) || (($chrs{$c} == ',') && ($top['what'] == SERVICES_JSON_SLICE))) { + // found a comma that is not inside a string, array, etc., + // OR we've reached the end of the character list + $slice = substr($chrs, $top['where'], ($c - $top['where'])); + array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false)); + //print("Found split at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n"); + + if (reset($stk) == SERVICES_JSON_IN_ARR) { + // we are in an array, so just push an element onto the stack + array_push($arr, $this->decode($slice)); + + } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) { + // we are in an object, so figure + // out the property name and set an + // element in an associative array, + // for now + $parts = array(); + + if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?$/Uis', $slice, $parts)) { + // "name":value pair + $key = $this->decode($parts[1]); + $val = $this->decode($parts[2]); + + if ($this->use & SERVICES_JSON_LOOSE_TYPE) { + $obj[$key] = $val; + } else { + $obj->$key = $val; + } + } elseif (preg_match('/^\s*(\w+)\s*:\s*(\S.*),?$/Uis', $slice, $parts)) { + // name:value pair, where name is unquoted + $key = $parts[1]; + $val = $this->decode($parts[2]); + + if ($this->use & SERVICES_JSON_LOOSE_TYPE) { + $obj[$key] = $val; + } else { + $obj->$key = $val; + } + } + + } + + } elseif ((($chrs{$c} == '"') || ($chrs{$c} == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) { + // found a quote, and we are not inside a string + array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs{$c})); + //print("Found start of string at {$c}\n"); + + } elseif (($chrs{$c} == $top['delim']) && + ($top['what'] == SERVICES_JSON_IN_STR) && + ((strlen(substr($chrs, 0, $c)) - strlen(rtrim(substr($chrs, 0, $c), '\\'))) % 2 != 1)) { + // found a quote, we're in a string, and it's not escaped + // we know that it's not escaped becase there is _not_ an + // odd number of backslashes at the end of the string so far + array_pop($stk); + //print("Found end of string at {$c}: ".substr($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n"); + + } elseif (($chrs{$c} == '[') && + in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) { + // found a left-bracket, and we are in an array, object, or slice + array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false)); + //print("Found start of array at {$c}\n"); + + } elseif (($chrs{$c} == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) { + // found a right-bracket, and we're in an array + array_pop($stk); + //print("Found end of array at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n"); + + } elseif (($chrs{$c} == '{') && + in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) { + // found a left-brace, and we are in an array, object, or slice + array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false)); + //print("Found start of object at {$c}\n"); + + } elseif (($chrs{$c} == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) { + // found a right-brace, and we're in an object + array_pop($stk); + //print("Found end of object at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n"); + + } elseif (($substr_chrs_c_2 == '/*') && + in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) { + // found a comment start, and we are in an array, object, or slice + array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false)); + $c++; + //print("Found start of comment at {$c}\n"); + + } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) { + // found a comment end, and we're in one now + array_pop($stk); + $c++; + + for ($i = $top['where']; $i <= $c; ++$i) + $chrs = substr_replace($chrs, ' ', $i, 1); + + //print("Found end of comment at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n"); + + } + + } + + if (reset($stk) == SERVICES_JSON_IN_ARR) { + return $arr; + + } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) { + return $obj; + + } + + } + } + } + + /** + * @todo Ultimately, this should just call PEAR::isError() + */ + function isError($data, $code = null) + { + if (class_exists('pear')) { + return PEAR::isError($data, $code); + } elseif (is_object($data) && (get_class($data) == 'json_error' || + is_subclass_of($data, 'json_error'))) { + return true; + } + + return false; + } +} + + + /** + * @todo Ultimately, this class shall be descended from PEAR_Error + */ + class JSON_Error + { + function JSON_Error($message = 'unknown error', $code = null, + $mode = null, $options = null, $userinfo = null) + { + + } + } + + +?> diff --git a/modules/util/JSqueeze.class.php b/modules/util/JSqueeze.class.php @@ -0,0 +1,1064 @@ +<?php + +/* + * Copyright (C) 2016 Nicolas Grekas - p@tchwork.com + * + * This library is free software; you can redistribute it and/or modify it + * under the terms of the (at your option): + * Apache License v2.0 (see provided LICENCE.ASL20 file), or + * GNU General Public License v2.0 (see provided LICENCE.GPLv2 file). + */ + +//namespace Patchwork; + +/* +* +* This class shrinks Javascript code +* (a process called minification nowadays) +* +* Should work with most valid Javascript code, +* even when semi-colons are missing. +* +* Features: +* - Removes comments and white spaces. +* - Renames every local vars, typically to a single character. +* - Renames also global vars, methods and properties, but only if they +* are marked special by some naming convention. By default, special +* var names begin with one or more "$", or with a single "_". +* - Renames also local/global vars found in strings, +* but only if they are marked special. +* - Keep Microsoft's conditional comments. +* - Output is optimized for later HTTP compression. +* +* Notes: +* - Source code must be parse error free before processing. +* - In order to maximise later HTTP compression (deflate, gzip), +* new variables names are chosen by considering closures, +* variables' frequency and characters' frequency. +* - If you use with/eval then be careful. +* +* Bonus: +* - Replaces false/true by !1/!0 +* - Replaces new Array/Object by []/{} +* - Merges consecutive "var" declarations with commas +* - Merges consecutive concatened strings +* - Fix a bug in Safari's parser (http://forums.asp.net/thread/1585609.aspx) +* - Can replace optional semi-colons by line feeds, +* thus facilitating output debugging. +* - Keep important comments marked with /*!... +* - Treats three semi-colons ;;; like single-line comments +* (http://dean.edwards.name/packer/2/usage/#triple-semi-colon). +* - Fix special catch scope across browsers +* - Work around buggy-handling of named function expressions in IE<=8 +* +* TODO? +* - foo['bar'] => foo.bar +* - {'foo':'bar'} => {foo:'bar'} +* - Dead code removal (never used function) +* - Munge primitives: var WINDOW=window, etc. +*/ + +class JSqueeze +{ + const + + SPECIAL_VAR_PACKER = '(\$+[a-zA-Z_]|_[a-zA-Z0-9$])[a-zA-Z0-9_$]*'; + + public + + $charFreq; + + protected + + $strings, + $closures, + $str0, + $str1, + $argFreq, + $specialVarRx, + $keepImportantComments, + + $varRx = '(?:[a-zA-Z_$])[a-zA-Z0-9_$]*', + $reserved = array( + // Literals + 'true','false','null', + // ES6 + 'break','case','class','catch','const','continue','debugger','default','delete','do','else','export','extends','finally','for','function','if','import','in','instanceof','new','return','super','switch','this','throw','try','typeof','var','void','while','with','yield', + // Future + 'enum', + // Strict mode + 'implements','package','protected','static','let','interface','private','public', + // Module + 'await', + // Older standards + 'abstract','boolean','byte','char','double','final','float','goto','int','long','native','short','synchronized','throws','transient','volatile', + ); + + public function __construct() + { + $this->reserved = array_flip($this->reserved); + $this->charFreq = array_fill(0, 256, 0); + } + + /** + * Squeezes a JavaScript source code. + * + * Set $singleLine to false if you want optional + * semi-colons to be replaced by line feeds. + * + * Set $keepImportantComments to false if you want /*! comments to be removed. + * + * $specialVarRx defines the regular expression of special variables names + * for global vars, methods, properties and in string substitution. + * Set it to false if you don't want any. + * + * If the analysed javascript source contains a single line comment like + * this one, then the directive will overwrite $specialVarRx: + * + * // jsqueeze.specialVarRx = your_special_var_regexp_here + * + * Only the first directive is parsed, others are ignored. It is not possible + * to redefine $specialVarRx in the middle of the javascript source. + * + * Example: + * $parser = new JSqueeze; + * $squeezed_js = $parser->squeeze($fat_js); + */ + public function squeeze($code, $singleLine = true, $keepImportantComments = true, $specialVarRx = false) + { + $code = trim($code); + if ('' === $code) { + return ''; + } + + $this->argFreq = array(-1 => 0); + $this->specialVarRx = $specialVarRx; + $this->keepImportantComments = !!$keepImportantComments; + + if (preg_match("#//[ \t]*jsqueeze\.specialVarRx[ \t]*=[ \t]*([\"']?)(.*)\\1#i", $code, $key)) { + if (!$key[1]) { + $key[2] = trim($key[2]); + $key[1] = strtolower($key[2]); + $key[1] = $key[1] && $key[1] != 'false' && $key[1] != 'none' && $key[1] != 'off'; + } + + $this->specialVarRx = $key[1] ? $key[2] : false; + } + + // Remove capturing parentheses + $this->specialVarRx && $this->specialVarRx = preg_replace('/(?<!\\\\)((?:\\\\\\\\)*)\((?!\?)/', '(?:', $this->specialVarRx); + + false !== strpos($code, "\r") && $code = strtr(str_replace("\r\n", "\n", $code), "\r", "\n"); + false !== strpos($code, "\xC2\x85") && $code = str_replace("\xC2\x85", "\n", $code); // Next Line + false !== strpos($code, "\xE2\x80\xA8") && $code = str_replace("\xE2\x80\xA8", "\n", $code); // Line Separator + false !== strpos($code, "\xE2\x80\xA9") && $code = str_replace("\xE2\x80\xA9", "\n", $code); // Paragraph Separator + + list($code, $this->strings) = $this->extractStrings($code); + list($code, $this->closures) = $this->extractClosures($code); + + $key = "//''\"\"#0'"; // This crap has a wonderful property: it can not happen in any valid javascript, even in strings + $this->closures[$key] = &$code; + + $tree = array($key => array('parent' => false)); + $this->makeVars($code, $tree[$key], $key); + $this->renameVars($tree[$key], true); + + $code = substr($tree[$key]['code'], 1); + $code = preg_replace("'\breturn !'", 'return!', $code); + $code = preg_replace("'\}(?=(else|while)[^\$.a-zA-Z0-9_])'", "}\r", $code); + $code = str_replace(array_keys($this->strings), array_values($this->strings), $code); + + if ($singleLine) { + $code = strtr($code, "\n", ';'); + } else { + $code = str_replace("\n", ";\n", $code); + } + false !== strpos($code, "\r") && $code = strtr(trim($code), "\r", "\n"); + + // Cleanup memory + $this->charFreq = array_fill(0, 256, 0); + $this->strings = $this->closures = $this->argFreq = array(); + $this->str0 = $this->str1 = ''; + + return $code; + } + + protected function extractStrings($f) + { + if ($cc_on = false !== strpos($f, '@cc_on')) { + // Protect conditional comments from being removed + $f = str_replace('#', '##', $f); + $f = str_replace('/*@', '1#@', $f); + $f = preg_replace("'//@([^\n]+)'", '2#@$1@#3', $f); + $f = str_replace('@*/', '@#1', $f); + } + + $len = strlen($f); + $code = str_repeat(' ', $len); + $j = 0; + + $strings = array(); + $K = 0; + + $instr = false; + + $q = array( + "'", '"', + "'" => 0, + '"' => 0, + ); + + // Extract strings, removes comments + for ($i = 0; $i < $len; ++$i) { + if ($instr) { + if ('//' == $instr) { + if ("\n" == $f[$i]) { + $f[$i--] = ' '; + $instr = false; + } + } elseif ($f[$i] == $instr || ('/' == $f[$i] && "/'" == $instr)) { + if ('!' == $instr) { + } elseif ('*' == $instr) { + if ('/' == $f[$i + 1]) { + ++$i; + $instr = false; + } + } else { + if ("/'" == $instr) { + while (isset($f[$i + 1]) && false !== strpos('gmi', $f[$i + 1])) { + $s[] = $f[$i++]; + } + $s[] = $f[$i]; + } + + $instr = false; + } + } elseif ('*' == $instr) { + } elseif ('!' == $instr) { + if ('*' == $f[$i] && '/' == $f[$i + 1]) { + $s[] = "*/\r"; + ++$i; + $instr = false; + } elseif ("\n" == $f[$i]) { + $s[] = "\r"; + } else { + $s[] = $f[$i]; + } + } elseif ('\\' == $f[$i]) { + ++$i; + + if ("\n" != $f[$i]) { + isset($q[$f[$i]]) && ++$q[$f[$i]]; + $s[] = '\\'.$f[$i]; + } + } elseif ('[' == $f[$i] && "/'" == $instr) { + $instr = '/['; + $s[] = '['; + } elseif (']' == $f[$i] && '/[' == $instr) { + $instr = "/'"; + $s[] = ']'; + } elseif ("'" == $f[$i] || '"' == $f[$i]) { + ++$q[$f[$i]]; + $s[] = '\\'.$f[$i]; + } else { + $s[] = $f[$i]; + } + } else { + switch ($f[$i]) { + case ';': + // Remove triple semi-colon + if ($i > 0 && ';' == $f[$i - 1] && $i + 1 < $len && ';' == $f[$i + 1]) { + $f[$i] = $f[$i + 1] = '/'; + } else { + $code[++$j] = ';'; + break; + } + + case '/': + if ('*' == $f[$i + 1]) { + ++$i; + $instr = '*'; + + if ($this->keepImportantComments && '!' == $f[$i + 1]) { + ++$i; + // no break here + } else { + break; + } + } elseif ('/' == $f[$i + 1]) { + ++$i; + $instr = '//'; + break; + } else { + $a = $j && (' ' == $code[$j] || "\x7F" == $code[$j]) ? $code[$j - 1] : $code[$j]; + if (false !== strpos('-!%&;<=>~:^+|,()*?[{} ', $a) + || (false !== strpos('oenfd', $a) + && preg_match( + "'(?<![\$.a-zA-Z0-9_])(do|else|return|typeof|yield[ \x7F]?\*?)[ \x7F]?$'", + substr($code, $j - 7, 8) + )) + ) { + if (')' === $a && $j > 1) { + $a = 1; + $k = $j - (' ' == $code[$j] || "\x7F" == $code[$j]) - 1; + while ($k >= 0 && $a) { + if ('(' === $code[$k]) { + --$a; + } elseif (')' === $code[$k]) { + ++$a; + } + --$k; + } + if (!preg_match("'(?<![\$.a-zA-Z0-9_])(if|for|while)[ \x7F]?$'", substr($code, 0, $k + 1))) { + $code[++$j] = '/'; + break; + } + } + + $key = "//''\"\"".$K++.$instr = "/'"; + $a = $j; + $code .= $key; + while (isset($key[++$j - $a - 1])) { + $code[$j] = $key[$j - $a - 1]; + } + --$j; + isset($s) && ($s = implode('', $s)) && $cc_on && $this->restoreCc($s); + $strings[$key] = array('/'); + $s = &$strings[$key]; + } else { + $code[++$j] = '/'; + } + + break; + } + + case "'": + case '"': + $instr = $f[$i]; + $key = "//''\"\"".$K++.('!' == $instr ? ']' : "'"); + $a = $j; + $code .= $key; + while (isset($key[++$j - $a - 1])) { + $code[$j] = $key[$j - $a - 1]; + } + --$j; + isset($s) && ($s = implode('', $s)) && $cc_on && $this->restoreCc($s); + $strings[$key] = array(); + $s = &$strings[$key]; + '!' == $instr && $s[] = "\r/*!"; + + break; + + case "\n": + if ($j > 3) { + if (' ' == $code[$j] || "\x7F" == $code[$j]) { + --$j; + } + + $code[++$j] = + false !== strpos('kend+-', $code[$j - 1]) + && preg_match( + "'(?:\+\+|--|(?<![\$.a-zA-Z0-9_])(break|continue|return|yield[ \x7F]?\*?))[ \x7F]?$'", + substr($code, $j - 8, 9) + ) + ? ';' : "\x7F"; + + break; + } + + case "\t": $f[$i] = ' '; + case ' ': + if (!$j || ' ' == $code[$j] || "\x7F" == $code[$j]) { + break; + } + + default: + $code[++$j] = $f[$i]; + } + } + } + + isset($s) && ($s = implode('', $s)) && $cc_on && $this->restoreCc($s); + unset($s); + + $code = substr($code, 0, $j + 1); + $cc_on && $this->restoreCc($code, false); + + // Protect wanted spaces and remove unwanted ones + $code = strtr($code, "\x7F", ' '); + $code = str_replace('- -', "-\x7F-", $code); + $code = str_replace('+ +', "+\x7F+", $code); + $code = preg_replace("'(\d)\s+\.\s*([a-zA-Z\$_[(])'", "$1\x7F.$2", $code); + $code = preg_replace("# ([-!%&;<=>~:.^+|,()*?[\]{}/']+)#", '$1', $code); + $code = preg_replace("#([-!%&;<=>~:.^+|,()*?[\]{}/]+) #", '$1', $code); + $cc_on && $code = preg_replace_callback("'//[^\'].*?@#3'", function ($m) { return strtr($m[0], ' ', "\x7F"); }, $code); + + // Replace new Array/Object by []/{} + false !== strpos($code, 'new Array') && $code = preg_replace("'new Array(?:\(\)|([;\])},:]))'", '[]$1', $code); + false !== strpos($code, 'new Object') && $code = preg_replace("'new Object(?:\(\)|([;\])},:]))'", '{}$1', $code); + + // Add missing semi-colons after curly braces + // This adds more semi-colons than strictly needed, + // but it seems that later gzipping is favorable to the repetition of "};" + $code = preg_replace("'\}(?![:,;.()\[\]}\|&]|(else|catch|finally|while)[^\$.a-zA-Z0-9_])'", '};', $code); + + // Tag possible empty instruction for easy detection + $code = preg_replace("'(?<![\$.a-zA-Z0-9_])if\('", '1#(', $code); + $code = preg_replace("'(?<![\$.a-zA-Z0-9_])for\('", '2#(', $code); + $code = preg_replace("'(?<![\$.a-zA-Z0-9_])while\('", '3#(', $code); + + $forPool = array(); + $instrPool = array(); + $s = 0; + + $f = array(); + $j = -1; + + // Remove as much semi-colon as possible + $len = strlen($code); + for ($i = 0; $i < $len; ++$i) { + switch ($code[$i]) { + case '(': + if ($j >= 0 && "\n" == $f[$j]) { + $f[$j] = ';'; + } + + ++$s; + + if ($i && '#' == $code[$i - 1]) { + $instrPool[$s - 1] = 1; + if ('2' == $code[$i - 2]) { + $forPool[$s] = 1; + } + } + + $f[++$j] = '('; + break; + + case ']': + case ')': + if ($i + 1 < $len && !isset($forPool[$s]) && !isset($instrPool[$s - 1]) && preg_match("'[a-zA-Z0-9_\$]'", $code[$i + 1])) { + $f[$j] .= $code[$i]; + $f[++$j] = "\n"; + } else { + $f[++$j] = $code[$i]; + } + + if (')' == $code[$i]) { + unset($forPool[$s]); + --$s; + } + + continue 2; + + case '}': + if ("\n" == $f[$j]) { + $f[$j] = '}'; + } else { + $f[++$j] = '}'; + } + break; + + case ';': + if (isset($forPool[$s]) || isset($instrPool[$s])) { + $f[++$j] = ';'; + } elseif ($j >= 0 && "\n" != $f[$j] && ';' != $f[$j]) { + $f[++$j] = "\n"; + } + + break; + + case '#': + switch ($f[$j]) { + case '1': $f[$j] = 'if'; break 2; + case '2': $f[$j] = 'for'; break 2; + case '3': $f[$j] = 'while'; break 2; + } + + case '['; + if ($j >= 0 && "\n" == $f[$j]) { + $f[$j] = ';'; + } + + default: $f[++$j] = $code[$i]; + } + + unset($instrPool[$s]); + } + + $f = implode('', $f); + $cc_on && $f = str_replace('@#3', "\r", $f); + + // Fix "else ;" empty instructions + $f = preg_replace("'(?<![\$.a-zA-Z0-9_])else\n'", "\n", $f); + + $r1 = array( // keywords with a direct object + 'case','delete','do','else','function','in','instanceof','of','break', + 'new','return','throw','typeof','var','void','yield','let','if', + 'const','get','set', + ); + + $r2 = array( // keywords with a subject + 'in','instanceof','of', + ); + + // Fix missing semi-colons + $f = preg_replace("'(?<!(?<![a-zA-Z0-9_\$])".implode(')(?<!(?<![a-zA-Z0-9_\$])', $r1).') (?!('.implode('|', $r2).")(?![a-zA-Z0-9_\$]))'", "\n", $f); + $f = preg_replace("'(?<!(?<![a-zA-Z0-9_\$])do)(?<!(?<![a-zA-Z0-9_\$])else) if\('", "\nif(", $f); + $f = preg_replace("'(?<=--|\+\+)(?<![a-zA-Z0-9_\$])(".implode('|', $r1).")(?![a-zA-Z0-9_\$])'", "\n$1", $f); + $f = preg_replace("'(?<![a-zA-Z0-9_\$])for\neach\('", 'for each(', $f); + $f = preg_replace("'(?<![a-zA-Z0-9_\$])\n(".implode('|', $r2).")(?![a-zA-Z0-9_\$])'", '$1', $f); + + // Merge strings + if ($q["'"] > $q['"']) { + $q = array($q[1], $q[0]); + } + $f = preg_replace("#//''\"\"[0-9]+'#", $q[0].'$0'.$q[0], $f); + strpos($f, $q[0].'+'.$q[0]) && $f = str_replace($q[0].'+'.$q[0], '', $f); + $len = count($strings); + foreach ($strings as $r1 => &$r2) { + $r2 = "/'" == substr($r1, -2) + ? str_replace(array("\\'", '\\"'), array("'", '"'), $r2) + : str_replace('\\'.$q[1], $q[1], $r2); + } + + // Restore wanted spaces + $f = strtr($f, "\x7F", ' '); + + return array($f, $strings); + } + + protected function extractClosures($code) + { + $code = ';'.$code; + + $this->argFreq[-1] += substr_count($code, '}catch('); + + if ($this->argFreq[-1]) { + // Special catch scope handling + + // FIXME: this implementation doesn't work with nested catch scopes who need + // access to their parent's caught variable (but who needs that?). + + $f = preg_split("@}catch\(({$this->varRx})@", $code, -1, PREG_SPLIT_DELIM_CAPTURE); + + $code = 'catch$scope$var'.mt_rand(); + $this->specialVarRx = $this->specialVarRx ? '(?:'.$this->specialVarRx.'|'.preg_quote($code).')' : preg_quote($code); + $i = count($f) - 1; + + while ($i) { + $c = 1; + $j = 0; + $l = strlen($f[$i]); + + while ($c && $j < $l) { + $s = $f[$i][$j++]; + $c += '(' == $s ? 1 : (')' == $s ? -1 : 0); + } + + if (!$c) { + do { + $s = $f[$i][$j++]; + $c += '{' == $s ? 1 : ('}' == $s ? -1 : 0); + } while ($c && $j < $l); + } + + $c = preg_quote($f[$i - 1], '#'); + $f[$i - 2] .= '}catch('.preg_replace("#([.,{]?)(?<![a-zA-Z0-9_\$@]){$c}\\b#", '$1'.$code, $f[$i - 1].substr($f[$i], 0, $j)).substr($f[$i], $j); + + unset($f[$i--], $f[$i--]); + } + + $code = $f[0]; + } + + $f = preg_split("'(?<![a-zA-Z0-9_\$])((?:function[ (]|get |set ).*?\{)'", $code, -1, PREG_SPLIT_DELIM_CAPTURE); + $i = count($f) - 1; + $closures = array(); + + while ($i) { + $c = 1; + $j = 0; + $l = strlen($f[$i]); + + while ($c && $j < $l) { + $s = $f[$i][$j++]; + $c += '{' == $s ? 1 : ('}' == $s ? -1 : 0); + } + + switch (substr($f[$i - 2], -1)) { + default: + if (false !== $c = strpos($f[$i - 1], ' ', 8)) { + break; + } + case false: case "\n": case ';': case '{': case '}': case ')': case ']': + $c = strpos($f[$i - 1], '(', 4); + } + + $l = "//''\"\"#$i'"; + $code = substr($f[$i - 1], $c); + $closures[$l] = $code.substr($f[$i], 0, $j); + $f[$i - 2] .= substr($f[$i - 1], 0, $c).$l.substr($f[$i], $j); + + if ('(){' !== $code) { + $j = substr_count($code, ','); + do { + isset($this->argFreq[$j]) ? ++$this->argFreq[$j] : $this->argFreq[$j] = 1; + } while ($j--); + } + + $i -= 2; + } + + return array($f[0], $closures); + } + + protected function makeVars($closure, &$tree, $key) + { + $tree['code'] = &$closure; + $tree['nfe'] = false; + $tree['used'] = array(); + $tree['local'] = array(); + + // Replace multiple "var" declarations by a single one + $closure = preg_replace_callback("'(?<=[\n\{\}])var [^\n\{\};]+(?:\nvar [^\n\{\};]+)+'", array($this, 'mergeVarDeclarations'), $closure); + + // Get all local vars (functions, arguments and "var" prefixed) + + $vars = &$tree['local']; + + if (preg_match("'^( [^(]*)?\((.*?)\)\{'", $closure, $v)) { + if ($v[1]) { + $vars[$tree['nfe'] = substr($v[1], 1)] = -1; + $tree['parent']['local'][';'.$key] = &$vars[$tree['nfe']]; + } + + if ($v[2]) { + $i = 0; + $v = explode(',', $v[2]); + foreach ($v as $w) { + $vars[$w] = $this->argFreq[$i++] - 1; // Give a bonus to argument variables + } + } + } + + $v = preg_split("'(?<![\$.a-zA-Z0-9_])var '", $closure); + if ($i = count($v) - 1) { + $w = array(); + + while ($i) { + $j = $c = 0; + $l = strlen($v[$i]); + + while ($j < $l) { + switch ($v[$i][$j]) { + case '(': case '[': case '{': + ++$c; + break; + + case ')': case ']': case '}': + if ($c-- <= 0) { + break 2; + } + break; + + case ';': case "\n": + if (!$c) { + break 2; + } + + default: + $c || $w[] = $v[$i][$j]; + } + + ++$j; + } + + $w[] = ','; + --$i; + } + + $v = explode(',', implode('', $w)); + foreach ($v as $w) { + if (preg_match("'^{$this->varRx}'", $w, $v)) { + isset($vars[$v[0]]) || $vars[$v[0]] = 0; + } + } + } + + if (preg_match_all("@function ({$this->varRx})//''\"\"#@", $closure, $v)) { + foreach ($v[1] as $w) { + isset($vars[$w]) || $vars[$w] = 0; + } + } + + if ($this->argFreq[-1] && preg_match_all("@}catch\(({$this->varRx})@", $closure, $v)) { + $v[0] = array(); + foreach ($v[1] as $w) { + isset($v[0][$w]) ? ++$v[0][$w] : $v[0][$w] = 1; + } + foreach ($v[0] as $w => $v) { + $vars[$w] = $this->argFreq[-1] - $v; + } + } + + // Get all used vars, local and non-local + + $vars = &$tree['used']; + + if (preg_match_all("#([.,{]?(?:[gs]et )?)(?<![a-zA-Z0-9_\$])({$this->varRx})(:?)#", $closure, $w, PREG_SET_ORDER)) { + foreach ($w as $k) { + if (isset($k[1][0]) && (',' === $k[1][0] || '{' === $k[1][0])) { + if (':' === $k[3]) { + $k = '.'.$k[2]; + } elseif ('get ' === substr($k[1], 1, 4) || 'set ' === substr($k[1], 1, 4)) { + ++$this->charFreq[ord($k[1][1])]; // "g" or "s" + ++$this->charFreq[101]; // "e" + ++$this->charFreq[116]; // "t" + $k = '.'.$k[2]; + } else { + $k = $k[2]; + } + } else { + $k = $k[1].$k[2]; + } + + isset($vars[$k]) ? ++$vars[$k] : $vars[$k] = 1; + } + } + + if (preg_match_all("#//''\"\"[0-9]+(?:['!]|/')#", $closure, $w)) { + foreach ($w[0] as $a) { + $v = "'" === substr($a, -1) && "/'" !== substr($a, -2) && $this->specialVarRx + ? preg_split("#([.,{]?(?:[gs]et )?(?<![a-zA-Z0-9_\$@]){$this->specialVarRx}:?)#", $this->strings[$a], -1, PREG_SPLIT_DELIM_CAPTURE) + : array($this->strings[$a]); + $a = count($v); + + for ($i = 0; $i < $a; ++$i) { + $k = $v[$i]; + + if (1 === $i % 2) { + if (',' === $k[0] || '{' === $k[0]) { + if (':' === substr($k, -1)) { + $k = '.'.substr($k, 1, -1); + } elseif ('get ' === substr($k, 1, 4) || 'set ' === substr($k, 1, 4)) { + ++$this->charFreq[ord($k[1])]; // "g" or "s" + ++$this->charFreq[101]; // "e" + ++$this->charFreq[116]; // "t" + $k = '.'.substr($k, 5); + } else { + $k = substr($k, 1); + } + } elseif (':' === substr($k, -1)) { + $k = substr($k, 0, -1); + } + + $w = &$tree; + + while (isset($w['parent']) && !(isset($w['used'][$k]) || isset($w['local'][$k]))) { + $w = &$w['parent']; + } + + (isset($w['used'][$k]) || isset($w['local'][$k])) && (isset($vars[$k]) ? ++$vars[$k] : $vars[$k] = 1); + + unset($w); + } + + if (0 === $i % 2 || !isset($vars[$k])) { + foreach (count_chars($v[$i], 1) as $k => $w) { + $this->charFreq[$k] += $w; + } + } + } + } + } + + // Propagate the usage number to parents + + foreach ($vars as $w => $a) { + $k = &$tree; + $chain = array(); + do { + $vars = &$k['local']; + $chain[] = &$k; + if (isset($vars[$w])) { + unset($k['used'][$w]); + if (isset($vars[$w])) { + $vars[$w] += $a; + } else { + $vars[$w] = $a; + } + $a = false; + break; + } + } while ($k['parent'] && $k = &$k['parent']); + + if ($a && !$k['parent']) { + if (isset($vars[$w])) { + $vars[$w] += $a; + } else { + $vars[$w] = $a; + } + } + + if (isset($tree['used'][$w]) && isset($vars[$w])) { + foreach ($chain as &$b) { + isset($b['local'][$w]) || $b['used'][$w] = &$vars[$w]; + } + } + } + + // Analyse childs + + $tree['childs'] = array(); + $vars = &$tree['childs']; + + if (preg_match_all("@//''\"\"#[0-9]+'@", $closure, $w)) { + foreach ($w[0] as $a) { + $vars[$a] = array('parent' => &$tree); + $this->makeVars($this->closures[$a], $vars[$a], $a); + } + } + } + + protected function mergeVarDeclarations($m) + { + return str_replace("\nvar ", ',', $m[0]); + } + + protected function renameVars(&$tree, $root) + { + if ($root) { + $tree['local'] += $tree['used']; + $tree['used'] = array(); + + foreach ($tree['local'] as $k => $v) { + if ('.' == $k[0]) { + $k = substr($k, 1); + } + + if ('true' === $k) { + $this->charFreq[48] += $v; + } elseif ('false' === $k) { + $this->charFreq[49] += $v; + } elseif (!$this->specialVarRx || !preg_match("#^{$this->specialVarRx}$#", $k)) { + foreach (count_chars($k, 1) as $k => $w) { + $this->charFreq[$k] += $w * $v; + } + } elseif (2 == strlen($k)) { + $tree['used'][] = $k[1]; + } + } + + $this->charFreq = $this->rsort($this->charFreq); + + $this->str0 = ''; + $this->str1 = ''; + + foreach ($this->charFreq as $k => $v) { + if (!$v) { + break; + } + + $v = chr($k); + + if ((64 < $k && $k < 91) || (96 < $k && $k < 123)) { // A-Z a-z + $this->str0 .= $v; + $this->str1 .= $v; + } elseif (47 < $k && $k < 58) { // 0-9 + $this->str1 .= $v; + } + } + + if ('' === $this->str0) { + $this->str0 = 'claspemitdbfrugnjvhowkxqyzCLASPEMITDBFRUGNJVHOWKXQYZ'; + $this->str1 = $this->str0.'0123456789'; + } + + foreach ($tree['local'] as $var => $root) { + if ('.' != substr($var, 0, 1) && isset($tree['local'][".{$var}"])) { + $tree['local'][$var] += $tree['local'][".{$var}"]; + } + } + + foreach ($tree['local'] as $var => $root) { + if ('.' == substr($var, 0, 1) && isset($tree['local'][substr($var, 1)])) { + $tree['local'][$var] = $tree['local'][substr($var, 1)]; + } + } + + $tree['local'] = $this->rsort($tree['local']); + + foreach ($tree['local'] as $var => $root) { + switch (substr($var, 0, 1)) { + case '.': + if (!isset($tree['local'][substr($var, 1)])) { + $tree['local'][$var] = '#'.($this->specialVarRx && 3 < strlen($var) && preg_match("'^\.{$this->specialVarRx}$'", $var) ? $this->getNextName($tree).'$' : substr($var, 1)); + } + break; + + case ';': $tree['local'][$var] = 0 === $root ? '' : $this->getNextName($tree); + case '#': break; + + default: + $root = $this->specialVarRx && 2 < strlen($var) && preg_match("'^{$this->specialVarRx}$'", $var) ? $this->getNextName($tree).'$' : $var; + $tree['local'][$var] = $root; + if (isset($tree['local'][".{$var}"])) { + $tree['local'][".{$var}"] = '#'.$root; + } + } + } + + foreach ($tree['local'] as $var => $root) { + $tree['local'][$var] = preg_replace("'^#'", '.', $tree['local'][$var]); + } + } else { + $tree['local'] = $this->rsort($tree['local']); + if (false !== $tree['nfe']) { + $tree['used'][] = $tree['local'][$tree['nfe']]; + } + + foreach ($tree['local'] as $var => $root) { + if ($tree['nfe'] !== $var) { + $tree['local'][$var] = 0 === $root ? '' : $this->getNextName($tree); + } + } + } + + $this->local_tree = &$tree['local']; + $this->used_tree = &$tree['used']; + + $tree['code'] = preg_replace_callback("#[.,{ ]?(?:[gs]et )?(?<![a-zA-Z0-9_\$@]){$this->varRx}:?#", array($this, 'getNewName'), $tree['code']); + + if ($this->specialVarRx && preg_match_all("#//''\"\"[0-9]+'#", $tree['code'], $b)) { + foreach ($b[0] as $a) { + $this->strings[$a] = preg_replace_callback( + "#[.,{]?(?:[gs]et )?(?<![a-zA-Z0-9_\$@]){$this->specialVarRx}:?#", + array($this, 'getNewName'), + $this->strings[$a] + ); + } + } + + foreach ($tree['childs'] as $a => &$b) { + $this->renameVars($b, false); + $tree['code'] = str_replace($a, $b['code'], $tree['code']); + unset($tree['childs'][$a]); + } + } + + protected function getNewName($m) + { + $m = $m[0]; + + $pre = '.' === $m[0] ? '.' : ''; + $post = ''; + + if (',' === $m[0] || '{' === $m[0] || ' ' === $m[0]) { + $pre = $m[0]; + + if (':' === substr($m, -1)) { + $post = ':'; + $m = (' ' !== $m[0] ? '.' : '').substr($m, 1, -1); + } elseif ('get ' === substr($m, 1, 4) || 'set ' === substr($m, 1, 4)) { + $pre .= substr($m, 1, 4); + $m = '.'.substr($m, 5); + } else { + $m = substr($m, 1); + } + } elseif (':' === substr($m, -1)) { + $post = ':'; + $m = substr($m, 0, -1); + } + + $post = (isset($this->reserved[$m]) + ? ('true' === $m ? '!0' : ('false' === $m ? '!1' : $m)) + : ( + isset($this->local_tree[$m]) + ? $this->local_tree[$m] + : ( + isset($this->used_tree[$m]) + ? $this->used_tree[$m] + : $m + ) + ) + ).$post; + + return '' === $post ? '' : ($pre.('.' === $post[0] ? substr($post, 1) : $post)); + } + + protected function getNextName(&$tree = array(), &$counter = false) + { + if (false === $counter) { + $counter = &$tree['counter']; + isset($counter) || $counter = -1; + $exclude = array_flip($tree['used']); + } else { + $exclude = $tree; + } + + ++$counter; + + $len0 = strlen($this->str0); + $len1 = strlen($this->str0); + + $name = $this->str0[$counter % $len0]; + + $i = intval($counter / $len0) - 1; + while ($i >= 0) { + $name .= $this->str1[ $i % $len1 ]; + $i = intval($i / $len1) - 1; + } + + return !(isset($this->reserved[$name]) || isset($exclude[$name])) ? $name : $this->getNextName($exclude, $counter); + } + + protected function restoreCc(&$s, $lf = true) + { + $lf && $s = str_replace('@#3', '', $s); + + $s = str_replace('@#1', '@*/', $s); + $s = str_replace('2#@', '//@', $s); + $s = str_replace('1#@', '/*@', $s); + $s = str_replace('##', '#', $s); + } + + private function rsort($array) + { + if (!$array) { + return $array; + } + + $i = 0; + $tuples = array(); + foreach ($array as $k => &$v) { + $tuples[] = array(++$i, $k, &$v); + } + + usort($tuples, function ($a, $b) { + if ($b[2] > $a[2]) { + return 1; + } + if ($b[2] < $a[2]) { + return -1; + } + if ($b[0] > $a[0]) { + return -1; + } + if ($b[0] < $a[0]) { + return 1; + } + + return 0; + }); + + $array = array(); + + foreach ($tuples as $t) { + $array[$t[1]] = &$t[2]; + } + + return $array; + } +} +?>+ \ No newline at end of file diff --git a/modules/util/Ldap.class.php b/modules/util/Ldap.class.php @@ -0,0 +1,182 @@ +<?php +// OpenRat Content Management System +// Copyright (C) 2002-2012 Jan Dankert, cms@jandankert.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 2 +// 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, write to the Free Software +// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + +/** + * Bereitstellen von LDAP-Funktionen. + * @author $Author$ + * @version $Revision$ + * @package openrat.services + */ +class Ldap +{ + var $connection; + var $timeout; + var $aliases; + + + /** + * + */ + function Ldap() + { + global $conf; + + $this->timeout = intval($conf['ldap']['search']['timeout']); + + if ( $conf['ldap']['search']['aliases'] ) + $this->aliases = LDAP_DEREF_ALWAYS; + else + $this->aliases = LDAP_DEREF_NEVER; + } + + + + /** + * Verbindung �ffnen. + */ + function connect() + { + global $conf; + + $ldapHost = $conf['ldap']['host']; + $ldapPort = $conf['ldap']['port']; + + // Verbindung zum LDAP-Server herstellen + $this->connection = @ldap_connect( $ldapHost,$ldapPort ); + + // siehe http://bugs.php.net/bug.php?id=15637 + // Unter bestimmten Bedingungen wird trotz nicht erreichbarem LDAP-Server eine PHP-Resource + // zurueck gegeben. Dann erscheint zwar keine Fehlermeldung, aber zumindestens misslingt + // der nachfolgende Bind-Befehl. + if ( !is_resource($this->connection) || $this->connection === false ) + { + Logger::error( "connect to ldap server '$ldapHost:$ldapPort' failed" ); + // Abbruch, wenn LDAP-Server nicht erreichbar + die( "Connection failed to $ldapHost:$ldapPort (".ldap_errno().'/'.ldap_error().'). Please contact your administrator.' ); + } + + // Protokollversion setzen. + $j = ldap_set_option( $this->connection, LDAP_OPT_PROTOCOL_VERSION,intval($conf['ldap']['protocol']) ); + if ( ! $j ) + die( 'LDAP error while setting protocol version'.ldap_errno().'/'.ldap_error().')' ); + + } + + + + /** + * Ein Binding auf den LDAP-Server durchf�hren. + */ + function bind( $user,$pw ) + { + return @ldap_bind( $this->connection,$user,$pw); + } + + + + /** + * Ein Binding auf den LDAP-Server durchf�hren. + */ + function bindAnonymous() + { + return @ldap_bind( $this->connection ); + } + + + + /** + * Das Bindung wird entfernt. + */ + function unbind() + { + ldap_unbind( $this->connection ); + } + + + + /** + * Eine Suche auf den LDAP-Server durchf�hren. + */ + function searchUser( $username ) + { + global $conf; + + $techUser = $conf['ldap']['search']['user']; + $techPass = $conf['ldap']['search']['password']; + + if ( $conf['ldap']['search']['anonymous'] ) + $this->bindAnonymous(); + else + $this->bind( $techUser, $techPass ); + + $dn = $conf['ldap']['search']['basedn']; + $filter = $conf['ldap']['search']['filter']; + $filter = str_replace('{user}', $username, $filter); + + $s = @ldap_search( $this->connection,$dn,$filter,array(),0,1,$this->timeout,$this->aliases ); + + if ( ! is_resource($s) ) + return null; + + $dn = @ldap_get_dn($this->connection, ldap_first_entry($this->connection,$s) ); + + return $dn; + } + + + + /** + * Ein Binding auf den LDAP-Server durchf�hren. + */ + function searchAttribute( $filter,$attr ) + { + global $conf; + + $timeout = intval($conf['ldap']['search']['timeout']); + + if ( $conf['ldap']['search']['aliases'] ) + $aliases = LDAP_DEREF_ALWAYS; + else + $aliases = LDAP_DEREF_NEVER; + + + $base_dn = $conf['ldap']['search']['basedn']; + $s = ldap_search( $this->connection,$base_dn,$filter,array(),0,0,$this->timeout,$this->aliases ); + $ergebnisse = ldap_get_entries($this->connection,$s); + + $liste = array(); +// Html::debug($ergebnisse); + for( $i=0; $i<=$ergebnisse['count']-1; $i++ ) + $liste[] = $ergebnisse[$i][$attr][0]; + + return $liste; + } + + + + /** + * Verbindung schlie�en. + */ + function close() + { + // Verbindung zum LDAP-Server brav beenden + ldap_close( $this->connection ); + } +} + +?>+ \ No newline at end of file diff --git a/modules/util/Less.php b/modules/util/Less.php @@ -0,0 +1,10524 @@ +<?php + +/** + * Class for parsing and compiling less files into css + * + * @package Less + * @subpackage parser + * + */ +class Less_Parser{ + + + /** + * Default parser options + */ + public static $default_options = array( + 'compress' => false, // option - whether to compress + 'strictUnits' => false, // whether units need to evaluate correctly + 'strictMath' => false, // whether math has to be within parenthesis + 'relativeUrls' => true, // option - whether to adjust URL's to be relative + 'urlArgs' => '', // whether to add args into url tokens + 'numPrecision' => 8, + + 'import_dirs' => array(), + 'import_callback' => null, + 'cache_dir' => null, + 'cache_method' => 'php', // false, 'serialize', 'php', 'var_export', 'callback'; + 'cache_callback_get' => null, + 'cache_callback_set' => null, + + 'sourceMap' => false, // whether to output a source map + 'sourceMapBasepath' => null, + 'sourceMapWriteTo' => null, + 'sourceMapURL' => null, + + 'indentation' => ' ', + + 'plugins' => array(), + + ); + + public static $options = array(); + + + private $input; // Less input string + private $input_len; // input string length + private $pos; // current index in `input` + private $saveStack = array(); // holds state for backtracking + private $furthest; + private $mb_internal_encoding = ''; // for remember exists value of mbstring.internal_encoding + + /** + * @var Less_Environment + */ + private $env; + + protected $rules = array(); + + private static $imports = array(); + + public static $has_extends = false; + + public static $next_id = 0; + + /** + * Filename to contents of all parsed the files + * + * @var array + */ + public static $contentsMap = array(); + + + /** + * @param Less_Environment|array|null $env + */ + public function __construct( $env = null ){ + + // Top parser on an import tree must be sure there is one "env" + // which will then be passed around by reference. + if( $env instanceof Less_Environment ){ + $this->env = $env; + }else{ + $this->SetOptions(Less_Parser::$default_options); + $this->Reset( $env ); + } + + // mbstring.func_overload > 1 bugfix + // The encoding value must be set for each source file, + // therefore, to conserve resources and improve the speed of this design is taken here + if (ini_get('mbstring.func_overload')) { + $this->mb_internal_encoding = ini_get('mbstring.internal_encoding'); + @ini_set('mbstring.internal_encoding', 'ascii'); + } + + } + + + /** + * Reset the parser state completely + * + */ + public function Reset( $options = null ){ + $this->rules = array(); + self::$imports = array(); + self::$has_extends = false; + self::$imports = array(); + self::$contentsMap = array(); + + $this->env = new Less_Environment($options); + $this->env->Init(); + + //set new options + if( is_array($options) ){ + $this->SetOptions(Less_Parser::$default_options); + $this->SetOptions($options); + } + } + + /** + * Set one or more compiler options + * options: import_dirs, cache_dir, cache_method + * + */ + public function SetOptions( $options ){ + foreach($options as $option => $value){ + $this->SetOption($option,$value); + } + } + + /** + * Set one compiler option + * + */ + public function SetOption($option,$value){ + + switch($option){ + + case 'import_dirs': + $this->SetImportDirs($value); + return; + + case 'cache_dir': + if( is_string($value) ){ + Less_Cache::SetCacheDir($value); + Less_Cache::CheckCacheDir(); + } + return; + } + + Less_Parser::$options[$option] = $value; + } + + /** + * Registers a new custom function + * + * @param string $name function name + * @param callable $callback callback + */ + public function registerFunction($name, $callback) { + $this->env->functions[$name] = $callback; + } + + /** + * Removed an already registered function + * + * @param string $name function name + */ + public function unregisterFunction($name) { + if( isset($this->env->functions[$name]) ) + unset($this->env->functions[$name]); + } + + + /** + * Get the current css buffer + * + * @return string + */ + public function getCss(){ + + $precision = ini_get('precision'); + @ini_set('precision',16); + $locale = setlocale(LC_NUMERIC, 0); + setlocale(LC_NUMERIC, "C"); + + try { + + $root = new Less_Tree_Ruleset(array(), $this->rules ); + $root->root = true; + $root->firstRoot = true; + + + $this->PreVisitors($root); + + self::$has_extends = false; + $evaldRoot = $root->compile($this->env); + + + + $this->PostVisitors($evaldRoot); + + if( Less_Parser::$options['sourceMap'] ){ + $generator = new Less_SourceMap_Generator($evaldRoot, Less_Parser::$contentsMap, Less_Parser::$options ); + // will also save file + // FIXME: should happen somewhere else? + $css = $generator->generateCSS(); + }else{ + $css = $evaldRoot->toCSS(); + } + + if( Less_Parser::$options['compress'] ){ + $css = preg_replace('/(^(\s)+)|((\s)+$)/', '', $css); + } + + } catch (Exception $exc) { + // Intentional fall-through so we can reset environment + } + + //reset php settings + @ini_set('precision',$precision); + setlocale(LC_NUMERIC, $locale); + + // If you previously defined $this->mb_internal_encoding + // is required to return the encoding as it was before + if ($this->mb_internal_encoding != '') { + @ini_set("mbstring.internal_encoding", $this->mb_internal_encoding); + $this->mb_internal_encoding = ''; + } + + // Rethrow exception after we handled resetting the environment + if (!empty($exc)) { + throw $exc; + } + + + + return $css; + } + + /** + * Run pre-compile visitors + * + */ + private function PreVisitors($root){ + + if( Less_Parser::$options['plugins'] ){ + foreach(Less_Parser::$options['plugins'] as $plugin){ + if( !empty($plugin->isPreEvalVisitor) ){ + $plugin->run($root); + } + } + } + } + + + /** + * Run post-compile visitors + * + */ + private function PostVisitors($evaldRoot){ + + $visitors = array(); + $visitors[] = new Less_Visitor_joinSelector(); + if( self::$has_extends ){ + $visitors[] = new Less_Visitor_processExtends(); + } + $visitors[] = new Less_Visitor_toCSS(); + + + if( Less_Parser::$options['plugins'] ){ + foreach(Less_Parser::$options['plugins'] as $plugin){ + if( property_exists($plugin,'isPreEvalVisitor') && $plugin->isPreEvalVisitor ){ + continue; + } + + if( property_exists($plugin,'isPreVisitor') && $plugin->isPreVisitor ){ + array_unshift( $visitors, $plugin); + }else{ + $visitors[] = $plugin; + } + } + } + + + for($i = 0; $i < count($visitors); $i++ ){ + $visitors[$i]->run($evaldRoot); + } + + } + + + /** + * Parse a Less string into css + * + * @param string $str The string to convert + * @param string $uri_root The url of the file + * @return Less_Tree_Ruleset|Less_Parser + */ + public function parse( $str, $file_uri = null ){ + + if( !$file_uri ){ + $uri_root = ''; + $filename = 'anonymous-file-'.Less_Parser::$next_id++.'.less'; + }else{ + $file_uri = self::WinPath($file_uri); + $filename = $file_uri; + $uri_root = dirname($file_uri); + } + + $previousFileInfo = $this->env->currentFileInfo; + $uri_root = self::WinPath($uri_root); + $this->SetFileInfo($filename, $uri_root); + + $this->input = $str; + $this->_parse(); + + if( $previousFileInfo ){ + $this->env->currentFileInfo = $previousFileInfo; + } + + return $this; + } + + + /** + * Parse a Less string from a given file + * + * @throws Less_Exception_Parser + * @param string $filename The file to parse + * @param string $uri_root The url of the file + * @param bool $returnRoot Indicates whether the return value should be a css string a root node + * @return Less_Tree_Ruleset|Less_Parser + */ + public function parseFile( $filename, $uri_root = '', $returnRoot = false){ + + if( !file_exists($filename) ){ + $this->Error(sprintf('File `%s` not found.', $filename)); + } + + + // fix uri_root? + // Instead of The mixture of file path for the first argument and directory path for the second argument has bee + if( !$returnRoot && !empty($uri_root) && basename($uri_root) == basename($filename) ){ + $uri_root = dirname($uri_root); + } + + + $previousFileInfo = $this->env->currentFileInfo; + + + if( $filename ){ + $filename = self::WinPath(realpath($filename)); + } + $uri_root = self::WinPath($uri_root); + + $this->SetFileInfo($filename, $uri_root); + + self::AddParsedFile($filename); + + if( $returnRoot ){ + $rules = $this->GetRules( $filename ); + $return = new Less_Tree_Ruleset(array(), $rules ); + }else{ + $this->_parse( $filename ); + $return = $this; + } + + if( $previousFileInfo ){ + $this->env->currentFileInfo = $previousFileInfo; + } + + return $return; + } + + + /** + * Allows a user to set variables values + * @param array $vars + * @return Less_Parser + */ + public function ModifyVars( $vars ){ + + $this->input = Less_Parser::serializeVars( $vars ); + $this->_parse(); + + return $this; + } + + + /** + * @param string $filename + */ + public function SetFileInfo( $filename, $uri_root = ''){ + + $filename = Less_Environment::normalizePath($filename); + $dirname = preg_replace('/[^\/\\\\]*$/','',$filename); + + if( !empty($uri_root) ){ + $uri_root = rtrim($uri_root,'/').'/'; + } + + $currentFileInfo = array(); + + //entry info + if( isset($this->env->currentFileInfo) ){ + $currentFileInfo['entryPath'] = $this->env->currentFileInfo['entryPath']; + $currentFileInfo['entryUri'] = $this->env->currentFileInfo['entryUri']; + $currentFileInfo['rootpath'] = $this->env->currentFileInfo['rootpath']; + + }else{ + $currentFileInfo['entryPath'] = $dirname; + $currentFileInfo['entryUri'] = $uri_root; + $currentFileInfo['rootpath'] = $dirname; + } + + $currentFileInfo['currentDirectory'] = $dirname; + $currentFileInfo['currentUri'] = $uri_root.basename($filename); + $currentFileInfo['filename'] = $filename; + $currentFileInfo['uri_root'] = $uri_root; + + + //inherit reference + if( isset($this->env->currentFileInfo['reference']) && $this->env->currentFileInfo['reference'] ){ + $currentFileInfo['reference'] = true; + } + + $this->env->currentFileInfo = $currentFileInfo; + } + + + /** + * @deprecated 1.5.1.2 + * + */ + public function SetCacheDir( $dir ){ + + if( !file_exists($dir) ){ + if( mkdir($dir) ){ + return true; + } + throw new Less_Exception_Parser('Less.php cache directory couldn\'t be created: '.$dir); + + }elseif( !is_dir($dir) ){ + throw new Less_Exception_Parser('Less.php cache directory doesn\'t exist: '.$dir); + + }elseif( !is_writable($dir) ){ + throw new Less_Exception_Parser('Less.php cache directory isn\'t writable: '.$dir); + + }else{ + $dir = self::WinPath($dir); + Less_Cache::$cache_dir = rtrim($dir,'/').'/'; + return true; + } + } + + + /** + * Set a list of directories or callbacks the parser should use for determining import paths + * + * @param array $dirs + */ + public function SetImportDirs( $dirs ){ + Less_Parser::$options['import_dirs'] = array(); + + foreach($dirs as $path => $uri_root){ + + $path = self::WinPath($path); + if( !empty($path) ){ + $path = rtrim($path,'/').'/'; + } + + if ( !is_callable($uri_root) ){ + $uri_root = self::WinPath($uri_root); + if( !empty($uri_root) ){ + $uri_root = rtrim($uri_root,'/').'/'; + } + } + + Less_Parser::$options['import_dirs'][$path] = $uri_root; + } + } + + /** + * @param string $file_path + */ + private function _parse( $file_path = null ){ + $this->rules = array_merge($this->rules, $this->GetRules( $file_path )); + } + + + /** + * Return the results of parsePrimary for $file_path + * Use cache and save cached results if possible + * + * @param string|null $file_path + */ + private function GetRules( $file_path ){ + + $this->SetInput($file_path); + + $cache_file = $this->CacheFile( $file_path ); + if( $cache_file ){ + if( Less_Parser::$options['cache_method'] == 'callback' ){ + if( is_callable(Less_Parser::$options['cache_callback_get']) ){ + $cache = call_user_func_array( + Less_Parser::$options['cache_callback_get'], + array($this, $file_path, $cache_file) + ); + + if( $cache ){ + $this->UnsetInput(); + return $cache; + } + } + + }elseif( file_exists($cache_file) ){ + switch(Less_Parser::$options['cache_method']){ + + // Using serialize + // Faster but uses more memory + case 'serialize': + $cache = unserialize(file_get_contents($cache_file)); + if( $cache ){ + touch($cache_file); + $this->UnsetInput(); + return $cache; + } + break; + + + // Using generated php code + case 'var_export': + case 'php': + $this->UnsetInput(); + return include($cache_file); + } + } + } + + $rules = $this->parsePrimary(); + + if( $this->pos < $this->input_len ){ + throw new Less_Exception_Chunk($this->input, null, $this->furthest, $this->env->currentFileInfo); + } + + $this->UnsetInput(); + + + //save the cache + if( $cache_file ){ + if( Less_Parser::$options['cache_method'] == 'callback' ){ + if( is_callable(Less_Parser::$options['cache_callback_set']) ){ + call_user_func_array( + Less_Parser::$options['cache_callback_set'], + array($this, $file_path, $cache_file, $rules) + ); + } + + }else{ + //msg('write cache file'); + switch(Less_Parser::$options['cache_method']){ + case 'serialize': + file_put_contents( $cache_file, serialize($rules) ); + break; + case 'php': + file_put_contents( $cache_file, '<?php return '.self::ArgString($rules).'; ?>' ); + break; + case 'var_export': + //Requires __set_state() + file_put_contents( $cache_file, '<?php return '.var_export($rules,true).'; ?>' ); + break; + } + + Less_Cache::CleanCache(); + } + } + + return $rules; + } + + + /** + * Set up the input buffer + * + */ + public function SetInput( $file_path ){ + + if( $file_path ){ + $this->input = file_get_contents( $file_path ); + } + + $this->pos = $this->furthest = 0; + + // Remove potential UTF Byte Order Mark + $this->input = preg_replace('/\\G\xEF\xBB\xBF/', '', $this->input); + $this->input_len = strlen($this->input); + + + if( Less_Parser::$options['sourceMap'] && $this->env->currentFileInfo ){ + $uri = $this->env->currentFileInfo['currentUri']; + Less_Parser::$contentsMap[$uri] = $this->input; + } + + } + + + /** + * Free up some memory + * + */ + public function UnsetInput(){ + unset($this->input, $this->pos, $this->input_len, $this->furthest); + $this->saveStack = array(); + } + + + public function CacheFile( $file_path ){ + + if( $file_path && $this->CacheEnabled() ){ + + $env = get_object_vars($this->env); + unset($env['frames']); + + $parts = array(); + $parts[] = $file_path; + $parts[] = filesize( $file_path ); + $parts[] = filemtime( $file_path ); + $parts[] = $env; + $parts[] = Less_Version::cache_version; + $parts[] = Less_Parser::$options['cache_method']; + return Less_Cache::$cache_dir . Less_Cache::$prefix . base_convert( sha1(json_encode($parts) ), 16, 36) . '.lesscache'; + } + } + + + static function AddParsedFile($file){ + self::$imports[] = $file; + } + + static function AllParsedFiles(){ + return self::$imports; + } + + /** + * @param string $file + */ + static function FileParsed($file){ + return in_array($file,self::$imports); + } + + + function save() { + $this->saveStack[] = $this->pos; + } + + private function restore() { + $this->pos = array_pop($this->saveStack); + } + + private function forget(){ + array_pop($this->saveStack); + } + + + private function isWhitespace($offset = 0) { + return preg_match('/\s/',$this->input[ $this->pos + $offset]); + } + + /** + * Parse from a token, regexp or string, and move forward if match + * + * @param array $toks + * @return array + */ + private function match($toks){ + + // The match is confirmed, add the match length to `this::pos`, + // and consume any extra white-space characters (' ' || '\n') + // which come after that. The reason for this is that LeSS's + // grammar is mostly white-space insensitive. + // + + foreach($toks as $tok){ + + $char = $tok[0]; + + if( $char === '/' ){ + $match = $this->MatchReg($tok); + + if( $match ){ + return count($match) === 1 ? $match[0] : $match; + } + + }elseif( $char === '#' ){ + $match = $this->MatchChar($tok[1]); + + }else{ + // Non-terminal, match using a function call + $match = $this->$tok(); + + } + + if( $match ){ + return $match; + } + } + } + + /** + * @param string[] $toks + * + * @return string + */ + private function MatchFuncs($toks){ + + if( $this->pos < $this->input_len ){ + foreach($toks as $tok){ + $match = $this->$tok(); + if( $match ){ + return $match; + } + } + } + + } + + // Match a single character in the input, + private function MatchChar($tok){ + if( ($this->pos < $this->input_len) && ($this->input[$this->pos] === $tok) ){ + $this->skipWhitespace(1); + return $tok; + } + } + + // Match a regexp from the current start point + private function MatchReg($tok){ + + if( preg_match($tok, $this->input, $match, 0, $this->pos) ){ + $this->skipWhitespace(strlen($match[0])); + return $match; + } + } + + + /** + * Same as match(), but don't change the state of the parser, + * just return the match. + * + * @param string $tok + * @return integer + */ + public function PeekReg($tok){ + return preg_match($tok, $this->input, $match, 0, $this->pos); + } + + /** + * @param string $tok + */ + public function PeekChar($tok){ + //return ($this->input[$this->pos] === $tok ); + return ($this->pos < $this->input_len) && ($this->input[$this->pos] === $tok ); + } + + + /** + * @param integer $length + */ + public function skipWhitespace($length){ + + $this->pos += $length; + + for(; $this->pos < $this->input_len; $this->pos++ ){ + $c = $this->input[$this->pos]; + + if( ($c !== "\n") && ($c !== "\r") && ($c !== "\t") && ($c !== ' ') ){ + break; + } + } + } + + + /** + * @param string $tok + * @param string|null $msg + */ + public function expect($tok, $msg = NULL) { + $result = $this->match( array($tok) ); + if (!$result) { + $this->Error( $msg ? "Expected '" . $tok . "' got '" . $this->input[$this->pos] . "'" : $msg ); + } else { + return $result; + } + } + + /** + * @param string $tok + */ + public function expectChar($tok, $msg = null ){ + $result = $this->MatchChar($tok); + if( !$result ){ + $this->Error( $msg ? "Expected '" . $tok . "' got '" . $this->input[$this->pos] . "'" : $msg ); + }else{ + return $result; + } + } + + // + // Here in, the parsing rules/functions + // + // The basic structure of the syntax tree generated is as follows: + // + // Ruleset -> Rule -> Value -> Expression -> Entity + // + // Here's some LESS code: + // + // .class { + // color: #fff; + // border: 1px solid #000; + // width: @w + 4px; + // > .child {...} + // } + // + // And here's what the parse tree might look like: + // + // Ruleset (Selector '.class', [ + // Rule ("color", Value ([Expression [Color #fff]])) + // Rule ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]])) + // Rule ("width", Value ([Expression [Operation "+" [Variable "@w"][Dimension 4px]]])) + // Ruleset (Selector [Element '>', '.child'], [...]) + // ]) + // + // In general, most rules will try to parse a token with the `$()` function, and if the return + // value is truly, will return a new node, of the relevant type. Sometimes, we need to check + // first, before parsing, that's when we use `peek()`. + // + + // + // The `primary` rule is the *entry* and *exit* point of the parser. + // The rules here can appear at any level of the parse tree. + // + // The recursive nature of the grammar is an interplay between the `block` + // rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule, + // as represented by this simplified grammar: + // + // primary → (ruleset | rule)+ + // ruleset → selector+ block + // block → '{' primary '}' + // + // Only at one point is the primary rule not called from the + // block rule: at the root level. + // + private function parsePrimary(){ + $root = array(); + + while( true ){ + + if( $this->pos >= $this->input_len ){ + break; + } + + $node = $this->parseExtend(true); + if( $node ){ + $root = array_merge($root,$node); + continue; + } + + //$node = $this->MatchFuncs( array( 'parseMixinDefinition', 'parseRule', 'parseRuleset', 'parseMixinCall', 'parseComment', 'parseDirective')); + $node = $this->MatchFuncs( array( 'parseMixinDefinition', 'parseNameValue', 'parseRule', 'parseRuleset', 'parseMixinCall', 'parseComment', 'parseRulesetCall', 'parseDirective')); + + if( $node ){ + $root[] = $node; + }elseif( !$this->MatchReg('/\\G[\s\n;]+/') ){ + break; + } + + if( $this->PeekChar('}') ){ + break; + } + } + + return $root; + } + + + + // We create a Comment node for CSS comments `/* */`, + // but keep the LeSS comments `//` silent, by just skipping + // over them. + private function parseComment(){ + + if( $this->input[$this->pos] !== '/' ){ + return; + } + + if( $this->input[$this->pos+1] === '/' ){ + $match = $this->MatchReg('/\\G\/\/.*/'); + return $this->NewObj4('Less_Tree_Comment',array($match[0], true, $this->pos, $this->env->currentFileInfo)); + } + + //$comment = $this->MatchReg('/\\G\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/'); + $comment = $this->MatchReg('/\\G\/\*(?s).*?\*+\/\n?/');//not the same as less.js to prevent fatal errors + if( $comment ){ + return $this->NewObj4('Less_Tree_Comment',array($comment[0], false, $this->pos, $this->env->currentFileInfo)); + } + } + + private function parseComments(){ + $comments = array(); + + while( $this->pos < $this->input_len ){ + $comment = $this->parseComment(); + if( !$comment ){ + break; + } + + $comments[] = $comment; + } + + return $comments; + } + + + + // + // A string, which supports escaping " and ' + // + // "milky way" 'he\'s the one!' + // + private function parseEntitiesQuoted() { + $j = $this->pos; + $e = false; + $index = $this->pos; + + if( $this->input[$this->pos] === '~' ){ + $j++; + $e = true; // Escaped strings + } + + if( $this->input[$j] != '"' && $this->input[$j] !== "'" ){ + return; + } + + if ($e) { + $this->MatchChar('~'); + } + + // Fix for #124: match escaped newlines + //$str = $this->MatchReg('/\\G"((?:[^"\\\\\r\n]|\\\\.)*)"|\'((?:[^\'\\\\\r\n]|\\\\.)*)\'/'); + $str = $this->MatchReg('/\\G"((?:[^"\\\\\r\n]|\\\\.|\\\\\r\n|\\\\[\n\r\f])*)"|\'((?:[^\'\\\\\r\n]|\\\\.|\\\\\r\n|\\\\[\n\r\f])*)\'/'); + + if( $str ){ + $result = $str[0][0] == '"' ? $str[1] : $str[2]; + return $this->NewObj5('Less_Tree_Quoted',array($str[0], $result, $e, $index, $this->env->currentFileInfo) ); + } + return; + } + + + // + // A catch-all word, such as: + // + // black border-collapse + // + private function parseEntitiesKeyword(){ + + //$k = $this->MatchReg('/\\G[_A-Za-z-][_A-Za-z0-9-]*/'); + $k = $this->MatchReg('/\\G%|\\G[_A-Za-z-][_A-Za-z0-9-]*/'); + if( $k ){ + $k = $k[0]; + $color = $this->fromKeyword($k); + if( $color ){ + return $color; + } + return $this->NewObj1('Less_Tree_Keyword',$k); + } + } + + // duplicate of Less_Tree_Color::FromKeyword + private function FromKeyword( $keyword ){ + $keyword = strtolower($keyword); + + if( Less_Colors::hasOwnProperty($keyword) ){ + // detect named color + return $this->NewObj1('Less_Tree_Color',substr(Less_Colors::color($keyword), 1)); + } + + if( $keyword === 'transparent' ){ + return $this->NewObj3('Less_Tree_Color', array( array(0, 0, 0), 0, true)); + } + } + + // + // A function call + // + // rgb(255, 0, 255) + // + // We also try to catch IE's `alpha()`, but let the `alpha` parser + // deal with the details. + // + // The arguments are parsed with the `entities.arguments` parser. + // + private function parseEntitiesCall(){ + $index = $this->pos; + + if( !preg_match('/\\G([\w-]+|%|progid:[\w\.]+)\(/', $this->input, $name,0,$this->pos) ){ + return; + } + $name = $name[1]; + $nameLC = strtolower($name); + + if ($nameLC === 'url') { + return null; + } + + $this->pos += strlen($name); + + if( $nameLC === 'alpha' ){ + $alpha_ret = $this->parseAlpha(); + if( $alpha_ret ){ + return $alpha_ret; + } + } + + $this->MatchChar('('); // Parse the '(' and consume whitespace. + + $args = $this->parseEntitiesArguments(); + + if( !$this->MatchChar(')') ){ + return; + } + + if ($name) { + return $this->NewObj4('Less_Tree_Call',array($name, $args, $index, $this->env->currentFileInfo) ); + } + } + + /** + * Parse a list of arguments + * + * @return array + */ + private function parseEntitiesArguments(){ + + $args = array(); + while( true ){ + $arg = $this->MatchFuncs( array('parseEntitiesAssignment','parseExpression') ); + if( !$arg ){ + break; + } + + $args[] = $arg; + if( !$this->MatchChar(',') ){ + break; + } + } + return $args; + } + + private function parseEntitiesLiteral(){ + return $this->MatchFuncs( array('parseEntitiesDimension','parseEntitiesColor','parseEntitiesQuoted','parseUnicodeDescriptor') ); + } + + // Assignments are argument entities for calls. + // They are present in ie filter properties as shown below. + // + // filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* ) + // + private function parseEntitiesAssignment() { + + $key = $this->MatchReg('/\\G\w+(?=\s?=)/'); + if( !$key ){ + return; + } + + if( !$this->MatchChar('=') ){ + return; + } + + $value = $this->parseEntity(); + if( $value ){ + return $this->NewObj2('Less_Tree_Assignment',array($key[0], $value)); + } + } + + // + // Parse url() tokens + // + // We use a specific rule for urls, because they don't really behave like + // standard function calls. The difference is that the argument doesn't have + // to be enclosed within a string, so it can't be parsed as an Expression. + // + private function parseEntitiesUrl(){ + + + if( $this->input[$this->pos] !== 'u' || !$this->matchReg('/\\Gurl\(/') ){ + return; + } + + $value = $this->match( array('parseEntitiesQuoted','parseEntitiesVariable','/\\Gdata\:.*?[^\)]+/','/\\G(?:(?:\\\\[\(\)\'"])|[^\(\)\'"])+/') ); + if( !$value ){ + $value = ''; + } + + + $this->expectChar(')'); + + + if( isset($value->value) || $value instanceof Less_Tree_Variable ){ + return $this->NewObj2('Less_Tree_Url',array($value, $this->env->currentFileInfo)); + } + + return $this->NewObj2('Less_Tree_Url', array( $this->NewObj1('Less_Tree_Anonymous',$value), $this->env->currentFileInfo) ); + } + + + // + // A Variable entity, such as `@fink`, in + // + // width: @fink + 2px + // + // We use a different parser for variable definitions, + // see `parsers.variable`. + // + private function parseEntitiesVariable(){ + $index = $this->pos; + if ($this->PeekChar('@') && ($name = $this->MatchReg('/\\G@@?[\w-]+/'))) { + return $this->NewObj3('Less_Tree_Variable', array( $name[0], $index, $this->env->currentFileInfo)); + } + } + + + // A variable entity useing the protective {} e.g. @{var} + private function parseEntitiesVariableCurly() { + $index = $this->pos; + + if( $this->input_len > ($this->pos+1) && $this->input[$this->pos] === '@' && ($curly = $this->MatchReg('/\\G@\{([\w-]+)\}/')) ){ + return $this->NewObj3('Less_Tree_Variable',array('@'.$curly[1], $index, $this->env->currentFileInfo)); + } + } + + // + // A Hexadecimal color + // + // #4F3C2F + // + // `rgb` and `hsl` colors are parsed through the `entities.call` parser. + // + private function parseEntitiesColor(){ + if ($this->PeekChar('#') && ($rgb = $this->MatchReg('/\\G#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/'))) { + return $this->NewObj1('Less_Tree_Color',$rgb[1]); + } + } + + // + // A Dimension, that is, a number and a unit + // + // 0.5em 95% + // + private function parseEntitiesDimension(){ + + $c = @ord($this->input[$this->pos]); + + //Is the first char of the dimension 0-9, '.', '+' or '-' + if (($c > 57 || $c < 43) || $c === 47 || $c == 44){ + return; + } + + $value = $this->MatchReg('/\\G([+-]?\d*\.?\d+)(%|[a-z]+)?/'); + if( $value ){ + + if( isset($value[2]) ){ + return $this->NewObj2('Less_Tree_Dimension', array($value[1],$value[2])); + } + return $this->NewObj1('Less_Tree_Dimension',$value[1]); + } + } + + + // + // A unicode descriptor, as is used in unicode-range + // + // U+0?? or U+00A1-00A9 + // + function parseUnicodeDescriptor() { + $ud = $this->MatchReg('/\\G(U\+[0-9a-fA-F?]+)(\-[0-9a-fA-F?]+)?/'); + if( $ud ){ + return $this->NewObj1('Less_Tree_UnicodeDescriptor', $ud[0]); + } + } + + + // + // JavaScript code to be evaluated + // + // `window.location.href` + // + private function parseEntitiesJavascript(){ + $e = false; + $j = $this->pos; + if( $this->input[$j] === '~' ){ + $j++; + $e = true; + } + if( $this->input[$j] !== '`' ){ + return; + } + if( $e ){ + $this->MatchChar('~'); + } + $str = $this->MatchReg('/\\G`([^`]*)`/'); + if( $str ){ + return $this->NewObj3('Less_Tree_Javascript', array($str[1], $this->pos, $e)); + } + } + + + // + // The variable part of a variable definition. Used in the `rule` parser + // + // @fink: + // + private function parseVariable(){ + if ($this->PeekChar('@') && ($name = $this->MatchReg('/\\G(@[\w-]+)\s*:/'))) { + return $name[1]; + } + } + + + // + // The variable part of a variable definition. Used in the `rule` parser + // + // @fink(); + // + private function parseRulesetCall(){ + + if( $this->input[$this->pos] === '@' && ($name = $this->MatchReg('/\\G(@[\w-]+)\s*\(\s*\)\s*;/')) ){ + return $this->NewObj1('Less_Tree_RulesetCall', $name[1] ); + } + } + + + // + // extend syntax - used to extend selectors + // + function parseExtend($isRule = false){ + + $index = $this->pos; + $extendList = array(); + + + if( !$this->MatchReg( $isRule ? '/\\G&:extend\(/' : '/\\G:extend\(/' ) ){ return; } + + do{ + $option = null; + $elements = array(); + while( true ){ + $option = $this->MatchReg('/\\G(all)(?=\s*(\)|,))/'); + if( $option ){ break; } + $e = $this->parseElement(); + if( !$e ){ break; } + $elements[] = $e; + } + + if( $option ){ + $option = $option[1]; + } + + $extendList[] = $this->NewObj3('Less_Tree_Extend', array( $this->NewObj1('Less_Tree_Selector',$elements), $option, $index )); + + }while( $this->MatchChar(",") ); + + $this->expect('/\\G\)/'); + + if( $isRule ){ + $this->expect('/\\G;/'); + } + + return $extendList; + } + + + // + // A Mixin call, with an optional argument list + // + // #mixins > .square(#fff); + // .rounded(4px, black); + // .button; + // + // The `while` loop is there because mixins can be + // namespaced, but we only support the child and descendant + // selector for now. + // + private function parseMixinCall(){ + + $char = $this->input[$this->pos]; + if( $char !== '.' && $char !== '#' ){ + return; + } + + $index = $this->pos; + $this->save(); // stop us absorbing part of an invalid selector + + $elements = $this->parseMixinCallElements(); + + if( $elements ){ + + if( $this->MatchChar('(') ){ + $returned = $this->parseMixinArgs(true); + $args = $returned['args']; + $this->expectChar(')'); + }else{ + $args = array(); + } + + $important = $this->parseImportant(); + + if( $this->parseEnd() ){ + $this->forget(); + return $this->NewObj5('Less_Tree_Mixin_Call', array( $elements, $args, $index, $this->env->currentFileInfo, $important)); + } + } + + $this->restore(); + } + + + private function parseMixinCallElements(){ + $elements = array(); + $c = null; + + while( true ){ + $elemIndex = $this->pos; + $e = $this->MatchReg('/\\G[#.](?:[\w-]|\\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/'); + if( !$e ){ + break; + } + $elements[] = $this->NewObj4('Less_Tree_Element', array($c, $e[0], $elemIndex, $this->env->currentFileInfo)); + $c = $this->MatchChar('>'); + } + + return $elements; + } + + + + /** + * @param boolean $isCall + */ + private function parseMixinArgs( $isCall ){ + $expressions = array(); + $argsSemiColon = array(); + $isSemiColonSeperated = null; + $argsComma = array(); + $expressionContainsNamed = null; + $name = null; + $returner = array('args'=>array(), 'variadic'=> false); + + $this->save(); + + while( true ){ + if( $isCall ){ + $arg = $this->MatchFuncs( array( 'parseDetachedRuleset','parseExpression' ) ); + } else { + $this->parseComments(); + if( $this->input[ $this->pos ] === '.' && $this->MatchReg('/\\G\.{3}/') ){ + $returner['variadic'] = true; + if( $this->MatchChar(";") && !$isSemiColonSeperated ){ + $isSemiColonSeperated = true; + } + + if( $isSemiColonSeperated ){ + $argsSemiColon[] = array('variadic'=>true); + }else{ + $argsComma[] = array('variadic'=>true); + } + break; + } + $arg = $this->MatchFuncs( array('parseEntitiesVariable','parseEntitiesLiteral','parseEntitiesKeyword') ); + } + + if( !$arg ){ + break; + } + + + $nameLoop = null; + if( $arg instanceof Less_Tree_Expression ){ + $arg->throwAwayComments(); + } + $value = $arg; + $val = null; + + if( $isCall ){ + // Variable + if( property_exists($arg,'value') && count($arg->value) == 1 ){ + $val = $arg->value[0]; + } + } else { + $val = $arg; + } + + + if( $val instanceof Less_Tree_Variable ){ + + if( $this->MatchChar(':') ){ + if( $expressions ){ + if( $isSemiColonSeperated ){ + $this->Error('Cannot mix ; and , as delimiter types'); + } + $expressionContainsNamed = true; + } + + // we do not support setting a ruleset as a default variable - it doesn't make sense + // However if we do want to add it, there is nothing blocking it, just don't error + // and remove isCall dependency below + $value = null; + if( $isCall ){ + $value = $this->parseDetachedRuleset(); + } + if( !$value ){ + $value = $this->parseExpression(); + } + + if( !$value ){ + if( $isCall ){ + $this->Error('could not understand value for named argument'); + } else { + $this->restore(); + $returner['args'] = array(); + return $returner; + } + } + + $nameLoop = ($name = $val->name); + }elseif( !$isCall && $this->MatchReg('/\\G\.{3}/') ){ + $returner['variadic'] = true; + if( $this->MatchChar(";") && !$isSemiColonSeperated ){ + $isSemiColonSeperated = true; + } + if( $isSemiColonSeperated ){ + $argsSemiColon[] = array('name'=> $arg->name, 'variadic' => true); + }else{ + $argsComma[] = array('name'=> $arg->name, 'variadic' => true); + } + break; + }elseif( !$isCall ){ + $name = $nameLoop = $val->name; + $value = null; + } + } + + if( $value ){ + $expressions[] = $value; + } + + $argsComma[] = array('name'=>$nameLoop, 'value'=>$value ); + + if( $this->MatchChar(',') ){ + continue; + } + + if( $this->MatchChar(';') || $isSemiColonSeperated ){ + + if( $expressionContainsNamed ){ + $this->Error('Cannot mix ; and , as delimiter types'); + } + + $isSemiColonSeperated = true; + + if( count($expressions) > 1 ){ + $value = $this->NewObj1('Less_Tree_Value', $expressions); + } + $argsSemiColon[] = array('name'=>$name, 'value'=>$value ); + + $name = null; + $expressions = array(); + $expressionContainsNamed = false; + } + } + + $this->forget(); + $returner['args'] = ($isSemiColonSeperated ? $argsSemiColon : $argsComma); + return $returner; + } + + + + // + // A Mixin definition, with a list of parameters + // + // .rounded (@radius: 2px, @color) { + // ... + // } + // + // Until we have a finer grained state-machine, we have to + // do a look-ahead, to make sure we don't have a mixin call. + // See the `rule` function for more information. + // + // We start by matching `.rounded (`, and then proceed on to + // the argument list, which has optional default values. + // We store the parameters in `params`, with a `value` key, + // if there is a value, such as in the case of `@radius`. + // + // Once we've got our params list, and a closing `)`, we parse + // the `{...}` block. + // + private function parseMixinDefinition(){ + $cond = null; + + $char = $this->input[$this->pos]; + if( ($char !== '.' && $char !== '#') || ($char === '{' && $this->PeekReg('/\\G[^{]*\}/')) ){ + return; + } + + $this->save(); + + $match = $this->MatchReg('/\\G([#.](?:[\w-]|\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/'); + if( $match ){ + $name = $match[1]; + + $argInfo = $this->parseMixinArgs( false ); + $params = $argInfo['args']; + $variadic = $argInfo['variadic']; + + + // .mixincall("@{a}"); + // looks a bit like a mixin definition.. + // also + // .mixincall(@a: {rule: set;}); + // so we have to be nice and restore + if( !$this->MatchChar(')') ){ + $this->furthest = $this->pos; + $this->restore(); + return; + } + + + $this->parseComments(); + + if ($this->MatchReg('/\\Gwhen/')) { // Guard + $cond = $this->expect('parseConditions', 'Expected conditions'); + } + + $ruleset = $this->parseBlock(); + + if( is_array($ruleset) ){ + $this->forget(); + return $this->NewObj5('Less_Tree_Mixin_Definition', array( $name, $params, $ruleset, $cond, $variadic)); + } + + $this->restore(); + }else{ + $this->forget(); + } + } + + // + // Entities are the smallest recognized token, + // and can be found inside a rule's value. + // + private function parseEntity(){ + + return $this->MatchFuncs( array('parseEntitiesLiteral','parseEntitiesVariable','parseEntitiesUrl','parseEntitiesCall','parseEntitiesKeyword','parseEntitiesJavascript','parseComment') ); + } + + // + // A Rule terminator. Note that we use `peek()` to check for '}', + // because the `block` rule will be expecting it, but we still need to make sure + // it's there, if ';' was ommitted. + // + private function parseEnd(){ + return $this->MatchChar(';') || $this->PeekChar('}'); + } + + // + // IE's alpha function + // + // alpha(opacity=88) + // + private function parseAlpha(){ + + if ( ! $this->MatchReg('/\\G\(opacity=/i')) { + return; + } + + $value = $this->MatchReg('/\\G[0-9]+/'); + if( $value ){ + $value = $value[0]; + }else{ + $value = $this->parseEntitiesVariable(); + if( !$value ){ + return; + } + } + + $this->expectChar(')'); + return $this->NewObj1('Less_Tree_Alpha',$value); + } + + + // + // A Selector Element + // + // div + // + h1 + // #socks + // input[type="text"] + // + // Elements are the building blocks for Selectors, + // they are made out of a `Combinator` (see combinator rule), + // and an element name, such as a tag a class, or `*`. + // + private function parseElement(){ + $c = $this->parseCombinator(); + $index = $this->pos; + + $e = $this->match( array('/\\G(?:\d+\.\d+|\d+)%/', '/\\G(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/', + '#*', '#&', 'parseAttribute', '/\\G\([^()@]+\)/', '/\\G[\.#](?=@)/', 'parseEntitiesVariableCurly') ); + + if( is_null($e) ){ + $this->save(); + if( $this->MatchChar('(') ){ + if( ($v = $this->parseSelector()) && $this->MatchChar(')') ){ + $e = $this->NewObj1('Less_Tree_Paren',$v); + $this->forget(); + }else{ + $this->restore(); + } + }else{ + $this->forget(); + } + } + + if( !is_null($e) ){ + return $this->NewObj4('Less_Tree_Element',array( $c, $e, $index, $this->env->currentFileInfo)); + } + } + + // + // Combinators combine elements together, in a Selector. + // + // Because our parser isn't white-space sensitive, special care + // has to be taken, when parsing the descendant combinator, ` `, + // as it's an empty space. We have to check the previous character + // in the input, to see if it's a ` ` character. + // + private function parseCombinator(){ + if( $this->pos < $this->input_len ){ + $c = $this->input[$this->pos]; + if ($c === '>' || $c === '+' || $c === '~' || $c === '|' || $c === '^' ){ + + $this->pos++; + if( $this->input[$this->pos] === '^' ){ + $c = '^^'; + $this->pos++; + } + + $this->skipWhitespace(0); + + return $c; + } + + if( $this->pos > 0 && $this->isWhitespace(-1) ){ + return ' '; + } + } + } + + // + // A CSS selector (see selector below) + // with less extensions e.g. the ability to extend and guard + // + private function parseLessSelector(){ + return $this->parseSelector(true); + } + + // + // A CSS Selector + // + // .class > div + h1 + // li a:hover + // + // Selectors are made out of one or more Elements, see above. + // + private function parseSelector( $isLess = false ){ + $elements = array(); + $extendList = array(); + $condition = null; + $when = false; + $extend = false; + $e = null; + $c = null; + $index = $this->pos; + + while( ($isLess && ($extend = $this->parseExtend())) || ($isLess && ($when = $this->MatchReg('/\\Gwhen/') )) || ($e = $this->parseElement()) ){ + if( $when ){ + $condition = $this->expect('parseConditions', 'expected condition'); + }elseif( $condition ){ + //error("CSS guard can only be used at the end of selector"); + }elseif( $extend ){ + $extendList = array_merge($extendList,$extend); + }else{ + //if( count($extendList) ){ + //error("Extend can only be used at the end of selector"); + //} + if( $this->pos < $this->input_len ){ + $c = $this->input[ $this->pos ]; + } + $elements[] = $e; + $e = null; + } + + if( $c === '{' || $c === '}' || $c === ';' || $c === ',' || $c === ')') { break; } + } + + if( $elements ){ + return $this->NewObj5('Less_Tree_Selector',array($elements, $extendList, $condition, $index, $this->env->currentFileInfo)); + } + if( $extendList ) { + $this->Error('Extend must be used to extend a selector, it cannot be used on its own'); + } + } + + private function parseTag(){ + return ( $tag = $this->MatchReg('/\\G[A-Za-z][A-Za-z-]*[0-9]?/') ) ? $tag : $this->MatchChar('*'); + } + + private function parseAttribute(){ + + $val = null; + + if( !$this->MatchChar('[') ){ + return; + } + + $key = $this->parseEntitiesVariableCurly(); + if( !$key ){ + $key = $this->expect('/\\G(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\\\.)+/'); + } + + $op = $this->MatchReg('/\\G[|~*$^]?=/'); + if( $op ){ + $val = $this->match( array('parseEntitiesQuoted','/\\G[0-9]+%/','/\\G[\w-]+/','parseEntitiesVariableCurly') ); + } + + $this->expectChar(']'); + + return $this->NewObj3('Less_Tree_Attribute',array( $key, $op[0], $val)); + } + + // + // The `block` rule is used by `ruleset` and `mixin.definition`. + // It's a wrapper around the `primary` rule, with added `{}`. + // + private function parseBlock(){ + if( $this->MatchChar('{') ){ + $content = $this->parsePrimary(); + if( $this->MatchChar('}') ){ + return $content; + } + } + } + + private function parseBlockRuleset(){ + $block = $this->parseBlock(); + + if( $block ){ + $block = $this->NewObj2('Less_Tree_Ruleset',array( null, $block)); + } + + return $block; + } + + private function parseDetachedRuleset(){ + $blockRuleset = $this->parseBlockRuleset(); + if( $blockRuleset ){ + return $this->NewObj1('Less_Tree_DetachedRuleset',$blockRuleset); + } + } + + // + // div, .class, body > p {...} + // + private function parseRuleset(){ + $selectors = array(); + + $this->save(); + + while( true ){ + $s = $this->parseLessSelector(); + if( !$s ){ + break; + } + $selectors[] = $s; + $this->parseComments(); + + if( $s->condition && count($selectors) > 1 ){ + $this->Error('Guards are only currently allowed on a single selector.'); + } + + if( !$this->MatchChar(',') ){ + break; + } + if( $s->condition ){ + $this->Error('Guards are only currently allowed on a single selector.'); + } + $this->parseComments(); + } + + + if( $selectors ){ + $rules = $this->parseBlock(); + if( is_array($rules) ){ + $this->forget(); + return $this->NewObj2('Less_Tree_Ruleset',array( $selectors, $rules)); //Less_Environment::$strictImports + } + } + + // Backtrack + $this->furthest = $this->pos; + $this->restore(); + } + + /** + * Custom less.php parse function for finding simple name-value css pairs + * ex: width:100px; + * + */ + private function parseNameValue(){ + + $index = $this->pos; + $this->save(); + + + //$match = $this->MatchReg('/\\G([a-zA-Z\-]+)\s*:\s*((?:\'")?[a-zA-Z0-9\-% \.,!]+?(?:\'")?)\s*([;}])/'); + $match = $this->MatchReg('/\\G([a-zA-Z\-]+)\s*:\s*([\'"]?[#a-zA-Z0-9\-%\.,]+?[\'"]?) *(! *important)?\s*([;}])/'); + if( $match ){ + + if( $match[4] == '}' ){ + $this->pos = $index + strlen($match[0])-1; + } + + if( $match[3] ){ + $match[2] .= ' !important'; + } + + return $this->NewObj4('Less_Tree_NameValue',array( $match[1], $match[2], $index, $this->env->currentFileInfo)); + } + + $this->restore(); + } + + + private function parseRule( $tryAnonymous = null ){ + + $merge = false; + $startOfRule = $this->pos; + + $c = $this->input[$this->pos]; + if( $c === '.' || $c === '#' || $c === '&' ){ + return; + } + + $this->save(); + $name = $this->MatchFuncs( array('parseVariable','parseRuleProperty')); + + if( $name ){ + + $isVariable = is_string($name); + + $value = null; + if( $isVariable ){ + $value = $this->parseDetachedRuleset(); + } + + $important = null; + if( !$value ){ + + // prefer to try to parse first if its a variable or we are compressing + // but always fallback on the other one + //if( !$tryAnonymous && is_string($name) && $name[0] === '@' ){ + if( !$tryAnonymous && (Less_Parser::$options['compress'] || $isVariable) ){ + $value = $this->MatchFuncs( array('parseValue','parseAnonymousValue')); + }else{ + $value = $this->MatchFuncs( array('parseAnonymousValue','parseValue')); + } + + $important = $this->parseImportant(); + + // a name returned by this.ruleProperty() is always an array of the form: + // [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"] + // where each item is a tree.Keyword or tree.Variable + if( !$isVariable && is_array($name) ){ + $nm = array_pop($name); + if( $nm->value ){ + $merge = $nm->value; + } + } + } + + + if( $value && $this->parseEnd() ){ + $this->forget(); + return $this->NewObj6('Less_Tree_Rule',array( $name, $value, $important, $merge, $startOfRule, $this->env->currentFileInfo)); + }else{ + $this->furthest = $this->pos; + $this->restore(); + if( $value && !$tryAnonymous ){ + return $this->parseRule(true); + } + } + }else{ + $this->forget(); + } + } + + function parseAnonymousValue(){ + + if( preg_match('/\\G([^@+\/\'"*`(;{}-]*);/',$this->input, $match, 0, $this->pos) ){ + $this->pos += strlen($match[1]); + return $this->NewObj1('Less_Tree_Anonymous',$match[1]); + } + } + + // + // An @import directive + // + // @import "lib"; + // + // Depending on our environment, importing is done differently: + // In the browser, it's an XHR request, in Node, it would be a + // file-system operation. The function used for importing is + // stored in `import`, which we pass to the Import constructor. + // + private function parseImport(){ + + $this->save(); + + $dir = $this->MatchReg('/\\G@import?\s+/'); + + if( $dir ){ + $options = $this->parseImportOptions(); + $path = $this->MatchFuncs( array('parseEntitiesQuoted','parseEntitiesUrl')); + + if( $path ){ + $features = $this->parseMediaFeatures(); + if( $this->MatchChar(';') ){ + if( $features ){ + $features = $this->NewObj1('Less_Tree_Value',$features); + } + + $this->forget(); + return $this->NewObj5('Less_Tree_Import',array( $path, $features, $options, $this->pos, $this->env->currentFileInfo)); + } + } + } + + $this->restore(); + } + + private function parseImportOptions(){ + + $options = array(); + + // list of options, surrounded by parens + if( !$this->MatchChar('(') ){ + return $options; + } + do{ + $optionName = $this->parseImportOption(); + if( $optionName ){ + $value = true; + switch( $optionName ){ + case "css": + $optionName = "less"; + $value = false; + break; + case "once": + $optionName = "multiple"; + $value = false; + break; + } + $options[$optionName] = $value; + if( !$this->MatchChar(',') ){ break; } + } + }while( $optionName ); + $this->expectChar(')'); + return $options; + } + + private function parseImportOption(){ + $opt = $this->MatchReg('/\\G(less|css|multiple|once|inline|reference|optional)/'); + if( $opt ){ + return $opt[1]; + } + } + + private function parseMediaFeature() { + $nodes = array(); + + do{ + $e = $this->MatchFuncs(array('parseEntitiesKeyword','parseEntitiesVariable')); + if( $e ){ + $nodes[] = $e; + } elseif ($this->MatchChar('(')) { + $p = $this->parseProperty(); + $e = $this->parseValue(); + if ($this->MatchChar(')')) { + if ($p && $e) { + $r = $this->NewObj7('Less_Tree_Rule', array( $p, $e, null, null, $this->pos, $this->env->currentFileInfo, true)); + $nodes[] = $this->NewObj1('Less_Tree_Paren',$r); + } elseif ($e) { + $nodes[] = $this->NewObj1('Less_Tree_Paren',$e); + } else { + return null; + } + } else + return null; + } + } while ($e); + + if ($nodes) { + return $this->NewObj1('Less_Tree_Expression',$nodes); + } + } + + private function parseMediaFeatures() { + $features = array(); + + do{ + $e = $this->parseMediaFeature(); + if( $e ){ + $features[] = $e; + if (!$this->MatchChar(',')) break; + }else{ + $e = $this->parseEntitiesVariable(); + if( $e ){ + $features[] = $e; + if (!$this->MatchChar(',')) break; + } + } + } while ($e); + + return $features ? $features : null; + } + + private function parseMedia() { + if( $this->MatchReg('/\\G@media/') ){ + $features = $this->parseMediaFeatures(); + $rules = $this->parseBlock(); + + if( is_array($rules) ){ + return $this->NewObj4('Less_Tree_Media',array( $rules, $features, $this->pos, $this->env->currentFileInfo)); + } + } + } + + + // + // A CSS Directive + // + // @charset "utf-8"; + // + private function parseDirective(){ + + if( !$this->PeekChar('@') ){ + return; + } + + $rules = null; + $index = $this->pos; + $hasBlock = true; + $hasIdentifier = false; + $hasExpression = false; + $hasUnknown = false; + + + $value = $this->MatchFuncs(array('parseImport','parseMedia')); + if( $value ){ + return $value; + } + + $this->save(); + + $name = $this->MatchReg('/\\G@[a-z-]+/'); + + if( !$name ) return; + $name = $name[0]; + + + $nonVendorSpecificName = $name; + $pos = strpos($name,'-', 2); + if( $name[1] == '-' && $pos > 0 ){ + $nonVendorSpecificName = "@" . substr($name, $pos + 1); + } + + + switch( $nonVendorSpecificName ){ + /* + case "@font-face": + case "@viewport": + case "@top-left": + case "@top-left-corner": + case "@top-center": + case "@top-right": + case "@top-right-corner": + case "@bottom-left": + case "@bottom-left-corner": + case "@bottom-center": + case "@bottom-right": + case "@bottom-right-corner": + case "@left-top": + case "@left-middle": + case "@left-bottom": + case "@right-top": + case "@right-middle": + case "@right-bottom": + hasBlock = true; + break; + */ + case "@charset": + $hasIdentifier = true; + $hasBlock = false; + break; + case "@namespace": + $hasExpression = true; + $hasBlock = false; + break; + case "@keyframes": + $hasIdentifier = true; + break; + case "@host": + case "@page": + case "@document": + case "@supports": + $hasUnknown = true; + break; + } + + if( $hasIdentifier ){ + $value = $this->parseEntity(); + if( !$value ){ + $this->error("expected " . $name . " identifier"); + } + } else if( $hasExpression ){ + $value = $this->parseExpression(); + if( !$value ){ + $this->error("expected " . $name. " expression"); + } + } else if ($hasUnknown) { + + $value = $this->MatchReg('/\\G[^{;]+/'); + if( $value ){ + $value = $this->NewObj1('Less_Tree_Anonymous',trim($value[0])); + } + } + + if( $hasBlock ){ + $rules = $this->parseBlockRuleset(); + } + + if( $rules || (!$hasBlock && $value && $this->MatchChar(';'))) { + $this->forget(); + return $this->NewObj5('Less_Tree_Directive',array($name, $value, $rules, $index, $this->env->currentFileInfo)); + } + + $this->restore(); + } + + + // + // A Value is a comma-delimited list of Expressions + // + // font-family: Baskerville, Georgia, serif; + // + // In a Rule, a Value represents everything after the `:`, + // and before the `;`. + // + private function parseValue(){ + $expressions = array(); + + do{ + $e = $this->parseExpression(); + if( $e ){ + $expressions[] = $e; + if (! $this->MatchChar(',')) { + break; + } + } + }while($e); + + if( $expressions ){ + return $this->NewObj1('Less_Tree_Value',$expressions); + } + } + + private function parseImportant (){ + if( $this->PeekChar('!') && $this->MatchReg('/\\G! *important/') ){ + return ' !important'; + } + } + + private function parseSub (){ + + if( $this->MatchChar('(') ){ + $a = $this->parseAddition(); + if( $a ){ + $this->expectChar(')'); + return $this->NewObj2('Less_Tree_Expression',array( array($a), true) ); //instead of $e->parens = true so the value is cached + } + } + } + + + /** + * Parses multiplication operation + * + * @return Less_Tree_Operation|null + */ + function parseMultiplication(){ + + $return = $m = $this->parseOperand(); + if( $return ){ + while( true ){ + + $isSpaced = $this->isWhitespace( -1 ); + + if( $this->PeekReg('/\\G\/[*\/]/') ){ + break; + } + + $op = $this->MatchChar('/'); + if( !$op ){ + $op = $this->MatchChar('*'); + if( !$op ){ + break; + } + } + + $a = $this->parseOperand(); + + if(!$a) { break; } + + $m->parensInOp = true; + $a->parensInOp = true; + $return = $this->NewObj3('Less_Tree_Operation',array( $op, array( $return, $a ), $isSpaced) ); + } + } + return $return; + + } + + + /** + * Parses an addition operation + * + * @return Less_Tree_Operation|null + */ + private function parseAddition (){ + + $return = $m = $this->parseMultiplication(); + if( $return ){ + while( true ){ + + $isSpaced = $this->isWhitespace( -1 ); + + $op = $this->MatchReg('/\\G[-+]\s+/'); + if( $op ){ + $op = $op[0]; + }else{ + if( !$isSpaced ){ + $op = $this->match(array('#+','#-')); + } + if( !$op ){ + break; + } + } + + $a = $this->parseMultiplication(); + if( !$a ){ + break; + } + + $m->parensInOp = true; + $a->parensInOp = true; + $return = $this->NewObj3('Less_Tree_Operation',array($op, array($return, $a), $isSpaced)); + } + } + + return $return; + } + + + /** + * Parses the conditions + * + * @return Less_Tree_Condition|null + */ + private function parseConditions() { + $index = $this->pos; + $return = $a = $this->parseCondition(); + if( $a ){ + while( true ){ + if( !$this->PeekReg('/\\G,\s*(not\s*)?\(/') || !$this->MatchChar(',') ){ + break; + } + $b = $this->parseCondition(); + if( !$b ){ + break; + } + + $return = $this->NewObj4('Less_Tree_Condition',array('or', $return, $b, $index)); + } + return $return; + } + } + + private function parseCondition() { + $index = $this->pos; + $negate = false; + $c = null; + + if ($this->MatchReg('/\\Gnot/')) $negate = true; + $this->expectChar('('); + $a = $this->MatchFuncs(array('parseAddition','parseEntitiesKeyword','parseEntitiesQuoted')); + + if( $a ){ + $op = $this->MatchReg('/\\G(?:>=|<=|=<|[<=>])/'); + if( $op ){ + $b = $this->MatchFuncs(array('parseAddition','parseEntitiesKeyword','parseEntitiesQuoted')); + if( $b ){ + $c = $this->NewObj5('Less_Tree_Condition',array($op[0], $a, $b, $index, $negate)); + } else { + $this->Error('Unexpected expression'); + } + } else { + $k = $this->NewObj1('Less_Tree_Keyword','true'); + $c = $this->NewObj5('Less_Tree_Condition',array('=', $a, $k, $index, $negate)); + } + $this->expectChar(')'); + return $this->MatchReg('/\\Gand/') ? $this->NewObj3('Less_Tree_Condition',array('and', $c, $this->parseCondition())) : $c; + } + } + + /** + * An operand is anything that can be part of an operation, + * such as a Color, or a Variable + * + */ + private function parseOperand (){ + + $negate = false; + $offset = $this->pos+1; + if( $offset >= $this->input_len ){ + return; + } + $char = $this->input[$offset]; + if( $char === '@' || $char === '(' ){ + $negate = $this->MatchChar('-'); + } + + $o = $this->MatchFuncs(array('parseSub','parseEntitiesDimension','parseEntitiesColor','parseEntitiesVariable','parseEntitiesCall')); + + if( $negate ){ + $o->parensInOp = true; + $o = $this->NewObj1('Less_Tree_Negative',$o); + } + + return $o; + } + + + /** + * Expressions either represent mathematical operations, + * or white-space delimited Entities. + * + * 1px solid black + * @var * 2 + * + * @return Less_Tree_Expression|null + */ + private function parseExpression (){ + $entities = array(); + + do{ + $e = $this->MatchFuncs(array('parseAddition','parseEntity')); + if( $e ){ + $entities[] = $e; + // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here + if( !$this->PeekReg('/\\G\/[\/*]/') ){ + $delim = $this->MatchChar('/'); + if( $delim ){ + $entities[] = $this->NewObj1('Less_Tree_Anonymous',$delim); + } + } + } + }while($e); + + if( $entities ){ + return $this->NewObj1('Less_Tree_Expression',$entities); + } + } + + + /** + * Parse a property + * eg: 'min-width', 'orientation', etc + * + * @return string + */ + private function parseProperty (){ + $name = $this->MatchReg('/\\G(\*?-?[_a-zA-Z0-9-]+)\s*:/'); + if( $name ){ + return $name[1]; + } + } + + + /** + * Parse a rule property + * eg: 'color', 'width', 'height', etc + * + * @return string + */ + private function parseRuleProperty(){ + $offset = $this->pos; + $name = array(); + $index = array(); + $length = 0; + + + $this->rulePropertyMatch('/\\G(\*?)/', $offset, $length, $index, $name ); + while( $this->rulePropertyMatch('/\\G((?:[\w-]+)|(?:@\{[\w-]+\}))/', $offset, $length, $index, $name )); // ! + + if( (count($name) > 1) && $this->rulePropertyMatch('/\\G\s*((?:\+_|\+)?)\s*:/', $offset, $length, $index, $name) ){ + // at last, we have the complete match now. move forward, + // convert name particles to tree objects and return: + $this->skipWhitespace($length); + + if( $name[0] === '' ){ + array_shift($name); + array_shift($index); + } + foreach($name as $k => $s ){ + if( !$s || $s[0] !== '@' ){ + $name[$k] = $this->NewObj1('Less_Tree_Keyword',$s); + }else{ + $name[$k] = $this->NewObj3('Less_Tree_Variable',array('@' . substr($s,2,-1), $index[$k], $this->env->currentFileInfo)); + } + } + return $name; + } + + + } + + private function rulePropertyMatch( $re, &$offset, &$length, &$index, &$name ){ + preg_match($re, $this->input, $a, 0, $offset); + if( $a ){ + $index[] = $this->pos + $length; + $length += strlen($a[0]); + $offset += strlen($a[0]); + $name[] = $a[1]; + return true; + } + } + + public static function serializeVars( $vars ){ + $s = ''; + + foreach($vars as $name => $value){ + $s .= (($name[0] === '@') ? '' : '@') . $name .': '. $value . ((substr($value,-1) === ';') ? '' : ';'); + } + + return $s; + } + + + /** + * Some versions of php have trouble with method_exists($a,$b) if $a is not an object + * + * @param string $b + */ + public static function is_method($a,$b){ + return is_object($a) && method_exists($a,$b); + } + + + /** + * Round numbers similarly to javascript + * eg: 1.499999 to 1 instead of 2 + * + */ + public static function round($i, $precision = 0){ + + $precision = pow(10,$precision); + $i = $i*$precision; + + $ceil = ceil($i); + $floor = floor($i); + if( ($ceil - $i) <= ($i - $floor) ){ + return $ceil/$precision; + }else{ + return $floor/$precision; + } + } + + + /** + * Create Less_Tree_* objects and optionally generate a cache string + * + * @return mixed + */ + public function NewObj0($class){ + $obj = new $class(); + if( $this->CacheEnabled() ){ + $obj->cache_string = ' new '.$class.'()'; + } + return $obj; + } + + public function NewObj1($class, $arg){ + $obj = new $class( $arg ); + if( $this->CacheEnabled() ){ + $obj->cache_string = ' new '.$class.'('.Less_Parser::ArgString($arg).')'; + } + return $obj; + } + + public function NewObj2($class, $args){ + $obj = new $class( $args[0], $args[1] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + public function NewObj3($class, $args){ + $obj = new $class( $args[0], $args[1], $args[2] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + public function NewObj4($class, $args){ + $obj = new $class( $args[0], $args[1], $args[2], $args[3] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + public function NewObj5($class, $args){ + $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + public function NewObj6($class, $args){ + $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4], $args[5] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + public function NewObj7($class, $args){ + $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4], $args[5], $args[6] ); + if( $this->CacheEnabled() ){ + $this->ObjCache( $obj, $class, $args); + } + return $obj; + } + + //caching + public function ObjCache($obj, $class, $args=array()){ + $obj->cache_string = ' new '.$class.'('. self::ArgCache($args).')'; + } + + public function ArgCache($args){ + return implode(',',array_map( array('Less_Parser','ArgString'),$args)); + } + + + /** + * Convert an argument to a string for use in the parser cache + * + * @return string + */ + public static function ArgString($arg){ + + $type = gettype($arg); + + if( $type === 'object'){ + $string = $arg->cache_string; + unset($arg->cache_string); + return $string; + + }elseif( $type === 'array' ){ + $string = ' Array('; + foreach($arg as $k => $a){ + $string .= var_export($k,true).' => '.self::ArgString($a).','; + } + return $string . ')'; + } + + return var_export($arg,true); + } + + public function Error($msg){ + throw new Less_Exception_Parser($msg, null, $this->furthest, $this->env->currentFileInfo); + } + + public static function WinPath($path){ + return str_replace('\\', '/', $path); + } + + public function CacheEnabled(){ + return false; + //return (Less_Parser::$options['cache_method'] && (Less_Cache::$cache_dir || (Less_Parser::$options['cache_method'] == 'callback'))); + } + +} + + +/** + * Utility for css colors + * + * @package Less + * @subpackage color + */ +class Less_Colors { + + public static $colors = array( + 'aliceblue'=>'#f0f8ff', + 'antiquewhite'=>'#faebd7', + 'aqua'=>'#00ffff', + 'aquamarine'=>'#7fffd4', + 'azure'=>'#f0ffff', + 'beige'=>'#f5f5dc', + 'bisque'=>'#ffe4c4', + 'black'=>'#000000', + 'blanchedalmond'=>'#ffebcd', + 'blue'=>'#0000ff', + 'blueviolet'=>'#8a2be2', + 'brown'=>'#a52a2a', + 'burlywood'=>'#deb887', + 'cadetblue'=>'#5f9ea0', + 'chartreuse'=>'#7fff00', + 'chocolate'=>'#d2691e', + 'coral'=>'#ff7f50', + 'cornflowerblue'=>'#6495ed', + 'cornsilk'=>'#fff8dc', + 'crimson'=>'#dc143c', + 'cyan'=>'#00ffff', + 'darkblue'=>'#00008b', + 'darkcyan'=>'#008b8b', + 'darkgoldenrod'=>'#b8860b', + 'darkgray'=>'#a9a9a9', + 'darkgrey'=>'#a9a9a9', + 'darkgreen'=>'#006400', + 'darkkhaki'=>'#bdb76b', + 'darkmagenta'=>'#8b008b', + 'darkolivegreen'=>'#556b2f', + 'darkorange'=>'#ff8c00', + 'darkorchid'=>'#9932cc', + 'darkred'=>'#8b0000', + 'darksalmon'=>'#e9967a', + 'darkseagreen'=>'#8fbc8f', + 'darkslateblue'=>'#483d8b', + 'darkslategray'=>'#2f4f4f', + 'darkslategrey'=>'#2f4f4f', + 'darkturquoise'=>'#00ced1', + 'darkviolet'=>'#9400d3', + 'deeppink'=>'#ff1493', + 'deepskyblue'=>'#00bfff', + 'dimgray'=>'#696969', + 'dimgrey'=>'#696969', + 'dodgerblue'=>'#1e90ff', + 'firebrick'=>'#b22222', + 'floralwhite'=>'#fffaf0', + 'forestgreen'=>'#228b22', + 'fuchsia'=>'#ff00ff', + 'gainsboro'=>'#dcdcdc', + 'ghostwhite'=>'#f8f8ff', + 'gold'=>'#ffd700', + 'goldenrod'=>'#daa520', + 'gray'=>'#808080', + 'grey'=>'#808080', + 'green'=>'#008000', + 'greenyellow'=>'#adff2f', + 'honeydew'=>'#f0fff0', + 'hotpink'=>'#ff69b4', + 'indianred'=>'#cd5c5c', + 'indigo'=>'#4b0082', + 'ivory'=>'#fffff0', + 'khaki'=>'#f0e68c', + 'lavender'=>'#e6e6fa', + 'lavenderblush'=>'#fff0f5', + 'lawngreen'=>'#7cfc00', + 'lemonchiffon'=>'#fffacd', + 'lightblue'=>'#add8e6', + 'lightcoral'=>'#f08080', + 'lightcyan'=>'#e0ffff', + 'lightgoldenrodyellow'=>'#fafad2', + 'lightgray'=>'#d3d3d3', + 'lightgrey'=>'#d3d3d3', + 'lightgreen'=>'#90ee90', + 'lightpink'=>'#ffb6c1', + 'lightsalmon'=>'#ffa07a', + 'lightseagreen'=>'#20b2aa', + 'lightskyblue'=>'#87cefa', + 'lightslategray'=>'#778899', + 'lightslategrey'=>'#778899', + 'lightsteelblue'=>'#b0c4de', + 'lightyellow'=>'#ffffe0', + 'lime'=>'#00ff00', + 'limegreen'=>'#32cd32', + 'linen'=>'#faf0e6', + 'magenta'=>'#ff00ff', + 'maroon'=>'#800000', + 'mediumaquamarine'=>'#66cdaa', + 'mediumblue'=>'#0000cd', + 'mediumorchid'=>'#ba55d3', + 'mediumpurple'=>'#9370d8', + 'mediumseagreen'=>'#3cb371', + 'mediumslateblue'=>'#7b68ee', + 'mediumspringgreen'=>'#00fa9a', + 'mediumturquoise'=>'#48d1cc', + 'mediumvioletred'=>'#c71585', + 'midnightblue'=>'#191970', + 'mintcream'=>'#f5fffa', + 'mistyrose'=>'#ffe4e1', + 'moccasin'=>'#ffe4b5', + 'navajowhite'=>'#ffdead', + 'navy'=>'#000080', + 'oldlace'=>'#fdf5e6', + 'olive'=>'#808000', + 'olivedrab'=>'#6b8e23', + 'orange'=>'#ffa500', + 'orangered'=>'#ff4500', + 'orchid'=>'#da70d6', + 'palegoldenrod'=>'#eee8aa', + 'palegreen'=>'#98fb98', + 'paleturquoise'=>'#afeeee', + 'palevioletred'=>'#d87093', + 'papayawhip'=>'#ffefd5', + 'peachpuff'=>'#ffdab9', + 'peru'=>'#cd853f', + 'pink'=>'#ffc0cb', + 'plum'=>'#dda0dd', + 'powderblue'=>'#b0e0e6', + 'purple'=>'#800080', + 'red'=>'#ff0000', + 'rosybrown'=>'#bc8f8f', + 'royalblue'=>'#4169e1', + 'saddlebrown'=>'#8b4513', + 'salmon'=>'#fa8072', + 'sandybrown'=>'#f4a460', + 'seagreen'=>'#2e8b57', + 'seashell'=>'#fff5ee', + 'sienna'=>'#a0522d', + 'silver'=>'#c0c0c0', + 'skyblue'=>'#87ceeb', + 'slateblue'=>'#6a5acd', + 'slategray'=>'#708090', + 'slategrey'=>'#708090', + 'snow'=>'#fffafa', + 'springgreen'=>'#00ff7f', + 'steelblue'=>'#4682b4', + 'tan'=>'#d2b48c', + 'teal'=>'#008080', + 'thistle'=>'#d8bfd8', + 'tomato'=>'#ff6347', + 'turquoise'=>'#40e0d0', + 'violet'=>'#ee82ee', + 'wheat'=>'#f5deb3', + 'white'=>'#ffffff', + 'whitesmoke'=>'#f5f5f5', + 'yellow'=>'#ffff00', + 'yellowgreen'=>'#9acd32' + ); + + public static function hasOwnProperty($color) { + return isset(self::$colors[$color]); + } + + + public static function color($color) { + return self::$colors[$color]; + } + +} + + + +/** + * Environment + * + * @package Less + * @subpackage environment + */ +class Less_Environment{ + + //public $paths = array(); // option - unmodified - paths to search for imports on + //public static $files = array(); // list of files that have been imported, used for import-once + //public $rootpath; // option - rootpath to append to URL's + //public static $strictImports = null; // option - + //public $insecure; // option - whether to allow imports from insecure ssl hosts + //public $processImports; // option - whether to process imports. if false then imports will not be imported + //public $javascriptEnabled; // option - whether JavaScript is enabled. if undefined, defaults to true + //public $useFileCache; // browser only - whether to use the per file session cache + public $currentFileInfo; // information about the current file - for error reporting and importing and making urls relative etc. + + public $importMultiple = false; // whether we are currently importing multiple copies + + + /** + * @var array + */ + public $frames = array(); + + /** + * @var array + */ + public $mediaBlocks = array(); + + /** + * @var array + */ + public $mediaPath = array(); + + public static $parensStack = 0; + + public static $tabLevel = 0; + + public static $lastRule = false; + + public static $_outputMap; + + public static $mixin_stack = 0; + + /** + * @var array + */ + public $functions = array(); + + + public function Init(){ + + self::$parensStack = 0; + self::$tabLevel = 0; + self::$lastRule = false; + self::$mixin_stack = 0; + + if( Less_Parser::$options['compress'] ){ + + Less_Environment::$_outputMap = array( + ',' => ',', + ': ' => ':', + '' => '', + ' ' => ' ', + ':' => ' :', + '+' => '+', + '~' => '~', + '>' => '>', + '|' => '|', + '^' => '^', + '^^' => '^^' + ); + + }else{ + + Less_Environment::$_outputMap = array( + ',' => ', ', + ': ' => ': ', + '' => '', + ' ' => ' ', + ':' => ' :', + '+' => ' + ', + '~' => ' ~ ', + '>' => ' > ', + '|' => '|', + '^' => ' ^ ', + '^^' => ' ^^ ' + ); + + } + } + + + public function copyEvalEnv($frames = array() ){ + $new_env = new Less_Environment(); + $new_env->frames = $frames; + return $new_env; + } + + + public static function isMathOn(){ + return !Less_Parser::$options['strictMath'] || Less_Environment::$parensStack; + } + + public static function isPathRelative($path){ + return !preg_match('/^(?:[a-z-]+:|\/)/',$path); + } + + + /** + * Canonicalize a path by resolving references to '/./', '/../' + * Does not remove leading "../" + * @param string path or url + * @return string Canonicalized path + * + */ + public static function normalizePath($path){ + + $segments = explode('/',$path); + $segments = array_reverse($segments); + + $path = array(); + $path_len = 0; + + while( $segments ){ + $segment = array_pop($segments); + switch( $segment ) { + + case '.': + break; + + case '..': + if( !$path_len || ( $path[$path_len-1] === '..') ){ + $path[] = $segment; + $path_len++; + }else{ + array_pop($path); + $path_len--; + } + break; + + default: + $path[] = $segment; + $path_len++; + break; + } + } + + return implode('/',$path); + } + + + public function unshiftFrame($frame){ + array_unshift($this->frames, $frame); + } + + public function shiftFrame(){ + return array_shift($this->frames); + } + +} + + +/** + * Builtin functions + * + * @package Less + * @subpackage function + * @see http://lesscss.org/functions/ + */ +class Less_Functions{ + + public $env; + public $currentFileInfo; + + function __construct($env, $currentFileInfo = null ){ + $this->env = $env; + $this->currentFileInfo = $currentFileInfo; + } + + /** + * @param string $op + */ + public static function operate( $op, $a, $b ){ + switch ($op) { + case '+': return $a + $b; + case '-': return $a - $b; + case '*': return $a * $b; + case '/': return $a / $b; + } + } + + public static function clamp($val, $max = 1){ + return min( max($val, 0), $max); + } + + public static function fround( $value ){ + + if( $value === 0 ){ + return $value; + } + + if( Less_Parser::$options['numPrecision'] ){ + $p = pow(10, Less_Parser::$options['numPrecision']); + return round( $value * $p) / $p; + } + return $value; + } + + public static function number($n){ + + if ($n instanceof Less_Tree_Dimension) { + return floatval( $n->unit->is('%') ? $n->value / 100 : $n->value); + } else if (is_numeric($n)) { + return $n; + } else { + throw new Less_Exception_Compiler("color functions take numbers as parameters"); + } + } + + public static function scaled($n, $size = 255 ){ + if( $n instanceof Less_Tree_Dimension && $n->unit->is('%') ){ + return (float)$n->value * $size / 100; + } else { + return Less_Functions::number($n); + } + } + + public function rgb ($r = null, $g = null, $b = null){ + if (is_null($r) || is_null($g) || is_null($b)) { + throw new Less_Exception_Compiler("rgb expects three parameters"); + } + return $this->rgba($r, $g, $b, 1.0); + } + + public function rgba($r = null, $g = null, $b = null, $a = null){ + $rgb = array($r, $g, $b); + $rgb = array_map(array('Less_Functions','scaled'),$rgb); + + $a = self::number($a); + return new Less_Tree_Color($rgb, $a); + } + + public function hsl($h, $s, $l){ + return $this->hsla($h, $s, $l, 1.0); + } + + public function hsla($h, $s, $l, $a){ + + $h = fmod(self::number($h), 360) / 360; // Classic % operator will change float to int + $s = self::clamp(self::number($s)); + $l = self::clamp(self::number($l)); + $a = self::clamp(self::number($a)); + + $m2 = $l <= 0.5 ? $l * ($s + 1) : $l + $s - $l * $s; + + $m1 = $l * 2 - $m2; + + return $this->rgba( self::hsla_hue($h + 1/3, $m1, $m2) * 255, + self::hsla_hue($h, $m1, $m2) * 255, + self::hsla_hue($h - 1/3, $m1, $m2) * 255, + $a); + } + + /** + * @param double $h + */ + public function hsla_hue($h, $m1, $m2){ + $h = $h < 0 ? $h + 1 : ($h > 1 ? $h - 1 : $h); + if ($h * 6 < 1) return $m1 + ($m2 - $m1) * $h * 6; + else if ($h * 2 < 1) return $m2; + else if ($h * 3 < 2) return $m1 + ($m2 - $m1) * (2/3 - $h) * 6; + else return $m1; + } + + public function hsv($h, $s, $v) { + return $this->hsva($h, $s, $v, 1.0); + } + + /** + * @param double $a + */ + public function hsva($h, $s, $v, $a) { + $h = ((Less_Functions::number($h) % 360) / 360 ) * 360; + $s = Less_Functions::number($s); + $v = Less_Functions::number($v); + $a = Less_Functions::number($a); + + $i = floor(($h / 60) % 6); + $f = ($h / 60) - $i; + + $vs = array( $v, + $v * (1 - $s), + $v * (1 - $f * $s), + $v * (1 - (1 - $f) * $s)); + + $perm = array(array(0, 3, 1), + array(2, 0, 1), + array(1, 0, 3), + array(1, 2, 0), + array(3, 1, 0), + array(0, 1, 2)); + + return $this->rgba($vs[$perm[$i][0]] * 255, + $vs[$perm[$i][1]] * 255, + $vs[$perm[$i][2]] * 255, + $a); + } + + public function hue($color = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to hue must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $c = $color->toHSL(); + return new Less_Tree_Dimension(Less_Parser::round($c['h'])); + } + + public function saturation($color = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to saturation must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $c = $color->toHSL(); + return new Less_Tree_Dimension(Less_Parser::round($c['s'] * 100), '%'); + } + + public function lightness($color = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to lightness must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $c = $color->toHSL(); + return new Less_Tree_Dimension(Less_Parser::round($c['l'] * 100), '%'); + } + + public function hsvhue( $color = null ){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to hsvhue must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsv = $color->toHSV(); + return new Less_Tree_Dimension( Less_Parser::round($hsv['h']) ); + } + + + public function hsvsaturation( $color = null ){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to hsvsaturation must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsv = $color->toHSV(); + return new Less_Tree_Dimension( Less_Parser::round($hsv['s'] * 100), '%' ); + } + + public function hsvvalue( $color = null ){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to hsvvalue must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsv = $color->toHSV(); + return new Less_Tree_Dimension( Less_Parser::round($hsv['v'] * 100), '%' ); + } + + public function red($color = null) { + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to red must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return new Less_Tree_Dimension( $color->rgb[0] ); + } + + public function green($color = null) { + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to green must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return new Less_Tree_Dimension( $color->rgb[1] ); + } + + public function blue($color = null) { + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to blue must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return new Less_Tree_Dimension( $color->rgb[2] ); + } + + public function alpha($color = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to alpha must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $c = $color->toHSL(); + return new Less_Tree_Dimension($c['a']); + } + + public function luma ($color = null) { + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to luma must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return new Less_Tree_Dimension(Less_Parser::round( $color->luma() * $color->alpha * 100), '%'); + } + + public function luminance( $color = null ){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to luminance must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $luminance = + (0.2126 * $color->rgb[0] / 255) + + (0.7152 * $color->rgb[1] / 255) + + (0.0722 * $color->rgb[2] / 255); + + return new Less_Tree_Dimension(Less_Parser::round( $luminance * $color->alpha * 100), '%'); + } + + public function saturate($color = null, $amount = null){ + // filter: saturate(3.2); + // should be kept as is, so check for color + if ($color instanceof Less_Tree_Dimension) { + return null; + } + + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to saturate must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to saturate must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + + $hsl['s'] += $amount->value / 100; + $hsl['s'] = self::clamp($hsl['s']); + + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + /** + * @param Less_Tree_Dimension $amount + */ + public function desaturate($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to desaturate must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to desaturate must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + + $hsl['s'] -= $amount->value / 100; + $hsl['s'] = self::clamp($hsl['s']); + + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + + + public function lighten($color = null, $amount=null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to lighten must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to lighten must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + + $hsl['l'] += $amount->value / 100; + $hsl['l'] = self::clamp($hsl['l']); + + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + public function darken($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to darken must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to darken must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + $hsl['l'] -= $amount->value / 100; + $hsl['l'] = self::clamp($hsl['l']); + + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + public function fadein($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to fadein must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to fadein must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + $hsl['a'] += $amount->value / 100; + $hsl['a'] = self::clamp($hsl['a']); + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + public function fadeout($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to fadeout must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to fadeout must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + $hsl['a'] -= $amount->value / 100; + $hsl['a'] = self::clamp($hsl['a']); + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + public function fade($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to fade must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to fade must be a percentage' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + + $hsl['a'] = $amount->value / 100; + $hsl['a'] = self::clamp($hsl['a']); + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + + + public function spin($color = null, $amount = null){ + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to spin must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$amount instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The second argument to spin must be a number' . ($amount instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $hsl = $color->toHSL(); + $hue = fmod($hsl['h'] + $amount->value, 360); + + $hsl['h'] = $hue < 0 ? 360 + $hue : $hue; + + return $this->hsla($hsl['h'], $hsl['s'], $hsl['l'], $hsl['a']); + } + + // + // Copyright (c) 2006-2009 Hampton Catlin, Nathan Weizenbaum, and Chris Eppstein + // http://sass-lang.com + // + + /** + * @param Less_Tree_Color $color1 + */ + public function mix($color1 = null, $color2 = null, $weight = null){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to mix must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to mix must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$weight) { + $weight = new Less_Tree_Dimension('50', '%'); + } + if (!$weight instanceof Less_Tree_Dimension) { + throw new Less_Exception_Compiler('The third argument to contrast must be a percentage' . ($weight instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + $p = $weight->value / 100.0; + $w = $p * 2 - 1; + $hsl1 = $color1->toHSL(); + $hsl2 = $color2->toHSL(); + $a = $hsl1['a'] - $hsl2['a']; + + $w1 = (((($w * $a) == -1) ? $w : ($w + $a) / (1 + $w * $a)) + 1) / 2; + $w2 = 1 - $w1; + + $rgb = array($color1->rgb[0] * $w1 + $color2->rgb[0] * $w2, + $color1->rgb[1] * $w1 + $color2->rgb[1] * $w2, + $color1->rgb[2] * $w1 + $color2->rgb[2] * $w2); + + $alpha = $color1->alpha * $p + $color2->alpha * (1 - $p); + + return new Less_Tree_Color($rgb, $alpha); + } + + public function greyscale($color){ + return $this->desaturate($color, new Less_Tree_Dimension(100,'%')); + } + + + public function contrast( $color, $dark = null, $light = null, $threshold = null){ + // filter: contrast(3.2); + // should be kept as is, so check for color + if (!$color instanceof Less_Tree_Color) { + return null; + } + if( !$light ){ + $light = $this->rgba(255, 255, 255, 1.0); + } + if( !$dark ){ + $dark = $this->rgba(0, 0, 0, 1.0); + } + + if (!$dark instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to contrast must be a color' . ($dark instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$light instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The third argument to contrast must be a color' . ($light instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + //Figure out which is actually light and dark! + if( $dark->luma() > $light->luma() ){ + $t = $light; + $light = $dark; + $dark = $t; + } + if( !$threshold ){ + $threshold = 0.43; + } else { + $threshold = Less_Functions::number($threshold); + } + + if( $color->luma() < $threshold ){ + return $light; + } else { + return $dark; + } + } + + public function e ($str){ + if( is_string($str) ){ + return new Less_Tree_Anonymous($str); + } + return new Less_Tree_Anonymous($str instanceof Less_Tree_JavaScript ? $str->expression : $str->value); + } + + public function escape ($str){ + + $revert = array('%21'=>'!', '%2A'=>'*', '%27'=>"'",'%3F'=>'?','%26'=>'&','%2C'=>',','%2F'=>'/','%40'=>'@','%2B'=>'+','%24'=>'$'); + + return new Less_Tree_Anonymous(strtr(rawurlencode($str->value), $revert)); + } + + + /** + * todo: This function will need some additional work to make it work the same as less.js + * + */ + public function replace( $string, $pattern, $replacement, $flags = null ){ + $result = $string->value; + + $expr = '/'.str_replace('/','\\/',$pattern->value).'/'; + if( $flags && $flags->value){ + $expr .= self::replace_flags($flags->value); + } + + $result = preg_replace($expr,$replacement->value,$result); + + + if( property_exists($string,'quote') ){ + return new Less_Tree_Quoted( $string->quote, $result, $string->escaped); + } + return new Less_Tree_Quoted( '', $result ); + } + + public static function replace_flags($flags){ + $flags = str_split($flags,1); + $new_flags = ''; + + foreach($flags as $flag){ + switch($flag){ + case 'e': + case 'g': + break; + + default: + $new_flags .= $flag; + break; + } + } + + return $new_flags; + } + + public function _percent(){ + $string = func_get_arg(0); + + $args = func_get_args(); + array_shift($args); + $result = $string->value; + + foreach($args as $arg){ + if( preg_match('/%[sda]/i',$result, $token) ){ + $token = $token[0]; + $value = stristr($token, 's') ? $arg->value : $arg->toCSS(); + $value = preg_match('/[A-Z]$/', $token) ? urlencode($value) : $value; + $result = preg_replace('/%[sda]/i',$value, $result, 1); + } + } + $result = str_replace('%%', '%', $result); + + return new Less_Tree_Quoted( $string->quote , $result, $string->escaped); + } + + public function unit( $val, $unit = null) { + if( !($val instanceof Less_Tree_Dimension) ){ + throw new Less_Exception_Compiler('The first argument to unit must be a number' . ($val instanceof Less_Tree_Operation ? '. Have you forgotten parenthesis?' : '.') ); + } + + if( $unit ){ + if( $unit instanceof Less_Tree_Keyword ){ + $unit = $unit->value; + } else { + $unit = $unit->toCSS(); + } + } else { + $unit = ""; + } + return new Less_Tree_Dimension($val->value, $unit ); + } + + public function convert($val, $unit){ + return $val->convertTo($unit->value); + } + + public function round($n, $f = false) { + + $fraction = 0; + if( $f !== false ){ + $fraction = $f->value; + } + + return $this->_math('Less_Parser::round',null, $n, $fraction); + } + + public function pi(){ + return new Less_Tree_Dimension(M_PI); + } + + public function mod($a, $b) { + return new Less_Tree_Dimension( $a->value % $b->value, $a->unit); + } + + + + public function pow($x, $y) { + if( is_numeric($x) && is_numeric($y) ){ + $x = new Less_Tree_Dimension($x); + $y = new Less_Tree_Dimension($y); + }elseif( !($x instanceof Less_Tree_Dimension) || !($y instanceof Less_Tree_Dimension) ){ + throw new Less_Exception_Compiler('Arguments must be numbers'); + } + + return new Less_Tree_Dimension( pow($x->value, $y->value), $x->unit ); + } + + // var mathFunctions = [{name:"ce ... + public function ceil( $n ){ return $this->_math('ceil', null, $n); } + public function floor( $n ){ return $this->_math('floor', null, $n); } + public function sqrt( $n ){ return $this->_math('sqrt', null, $n); } + public function abs( $n ){ return $this->_math('abs', null, $n); } + + public function tan( $n ){ return $this->_math('tan', '', $n); } + public function sin( $n ){ return $this->_math('sin', '', $n); } + public function cos( $n ){ return $this->_math('cos', '', $n); } + + public function atan( $n ){ return $this->_math('atan', 'rad', $n); } + public function asin( $n ){ return $this->_math('asin', 'rad', $n); } + public function acos( $n ){ return $this->_math('acos', 'rad', $n); } + + private function _math() { + $args = func_get_args(); + $fn = array_shift($args); + $unit = array_shift($args); + + if ($args[0] instanceof Less_Tree_Dimension) { + + if( $unit === null ){ + $unit = $args[0]->unit; + }else{ + $args[0] = $args[0]->unify(); + } + $args[0] = (float)$args[0]->value; + return new Less_Tree_Dimension( call_user_func_array($fn, $args), $unit); + } else if (is_numeric($args[0])) { + return call_user_func_array($fn,$args); + } else { + throw new Less_Exception_Compiler("math functions take numbers as parameters"); + } + } + + /** + * @param boolean $isMin + */ + private function _minmax( $isMin, $args ){ + + $arg_count = count($args); + + if( $arg_count < 1 ){ + throw new Less_Exception_Compiler( 'one or more arguments required'); + } + + $j = null; + $unitClone = null; + $unitStatic = null; + + + $order = array(); // elems only contains original argument values. + $values = array(); // key is the unit.toString() for unified tree.Dimension values, + // value is the index into the order array. + + + for( $i = 0; $i < $arg_count; $i++ ){ + $current = $args[$i]; + if( !($current instanceof Less_Tree_Dimension) ){ + if( is_array($args[$i]->value) ){ + $args[] = $args[$i]->value; + } + continue; + } + + if( $current->unit->toString() === '' && !$unitClone ){ + $temp = new Less_Tree_Dimension($current->value, $unitClone); + $currentUnified = $temp->unify(); + }else{ + $currentUnified = $current->unify(); + } + + if( $currentUnified->unit->toString() === "" && !$unitStatic ){ + $unit = $unitStatic; + }else{ + $unit = $currentUnified->unit->toString(); + } + + if( $unit !== '' && !$unitStatic || $unit !== '' && $order[0]->unify()->unit->toString() === "" ){ + $unitStatic = $unit; + } + + if( $unit != '' && !$unitClone ){ + $unitClone = $current->unit->toString(); + } + + if( isset($values['']) && $unit !== '' && $unit === $unitStatic ){ + $j = $values['']; + }elseif( isset($values[$unit]) ){ + $j = $values[$unit]; + }else{ + + if( $unitStatic && $unit !== $unitStatic ){ + throw new Less_Exception_Compiler( 'incompatible types'); + } + $values[$unit] = count($order); + $order[] = $current; + continue; + } + + + if( $order[$j]->unit->toString() === "" && $unitClone ){ + $temp = new Less_Tree_Dimension( $order[$j]->value, $unitClone); + $referenceUnified = $temp->unify(); + }else{ + $referenceUnified = $order[$j]->unify(); + } + if( ($isMin && $currentUnified->value < $referenceUnified->value) || (!$isMin && $currentUnified->value > $referenceUnified->value) ){ + $order[$j] = $current; + } + } + + if( count($order) == 1 ){ + return $order[0]; + } + $args = array(); + foreach($order as $a){ + $args[] = $a->toCSS($this->env); + } + return new Less_Tree_Anonymous( ($isMin?'min(':'max(') . implode(Less_Environment::$_outputMap[','],$args).')'); + } + + public function min(){ + $args = func_get_args(); + return $this->_minmax( true, $args ); + } + + public function max(){ + $args = func_get_args(); + return $this->_minmax( false, $args ); + } + + public function getunit($n){ + return new Less_Tree_Anonymous($n->unit); + } + + public function argb($color) { + if (!$color instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to argb must be a color' . ($color instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return new Less_Tree_Anonymous($color->toARGB()); + } + + public function percentage($n) { + return new Less_Tree_Dimension($n->value * 100, '%'); + } + + public function color($n) { + + if( $n instanceof Less_Tree_Quoted ){ + $colorCandidate = $n->value; + $returnColor = Less_Tree_Color::fromKeyword($colorCandidate); + if( $returnColor ){ + return $returnColor; + } + if( preg_match('/^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/',$colorCandidate) ){ + return new Less_Tree_Color(substr($colorCandidate, 1)); + } + throw new Less_Exception_Compiler("argument must be a color keyword or 3/6 digit hex e.g. #FFF"); + } else { + throw new Less_Exception_Compiler("argument must be a string"); + } + } + + + public function iscolor($n) { + return $this->_isa($n, 'Less_Tree_Color'); + } + + public function isnumber($n) { + return $this->_isa($n, 'Less_Tree_Dimension'); + } + + public function isstring($n) { + return $this->_isa($n, 'Less_Tree_Quoted'); + } + + public function iskeyword($n) { + return $this->_isa($n, 'Less_Tree_Keyword'); + } + + public function isurl($n) { + return $this->_isa($n, 'Less_Tree_Url'); + } + + public function ispixel($n) { + return $this->isunit($n, 'px'); + } + + public function ispercentage($n) { + return $this->isunit($n, '%'); + } + + public function isem($n) { + return $this->isunit($n, 'em'); + } + + /** + * @param string $unit + */ + public function isunit( $n, $unit ){ + return ($n instanceof Less_Tree_Dimension) && $n->unit->is( ( property_exists($unit,'value') ? $unit->value : $unit) ) ? new Less_Tree_Keyword('true') : new Less_Tree_Keyword('false'); + } + + /** + * @param string $type + */ + private function _isa($n, $type) { + return is_a($n, $type) ? new Less_Tree_Keyword('true') : new Less_Tree_Keyword('false'); + } + + public function tint($color, $amount) { + return $this->mix( $this->rgb(255,255,255), $color, $amount); + } + + public function shade($color, $amount) { + return $this->mix($this->rgb(0, 0, 0), $color, $amount); + } + + public function extract($values, $index ){ + $index = (int)$index->value - 1; // (1-based index) + // handle non-array values as an array of length 1 + // return 'undefined' if index is invalid + if( property_exists($values,'value') && is_array($values->value) ){ + if( isset($values->value[$index]) ){ + return $values->value[$index]; + } + return null; + + }elseif( (int)$index === 0 ){ + return $values; + } + + return null; + } + + public function length($values){ + $n = (property_exists($values,'value') && is_array($values->value)) ? count($values->value) : 1; + return new Less_Tree_Dimension($n); + } + + public function datauri($mimetypeNode, $filePathNode = null ) { + + $filePath = ( $filePathNode ? $filePathNode->value : null ); + $mimetype = $mimetypeNode->value; + + $args = 2; + if( !$filePath ){ + $filePath = $mimetype; + $args = 1; + } + + $filePath = str_replace('\\','/',$filePath); + if( Less_Environment::isPathRelative($filePath) ){ + + if( Less_Parser::$options['relativeUrls'] ){ + $temp = $this->currentFileInfo['currentDirectory']; + } else { + $temp = $this->currentFileInfo['entryPath']; + } + + if( !empty($temp) ){ + $filePath = Less_Environment::normalizePath(rtrim($temp,'/').'/'.$filePath); + } + + } + + + // detect the mimetype if not given + if( $args < 2 ){ + + /* incomplete + $mime = require('mime'); + mimetype = mime.lookup(path); + + // use base 64 unless it's an ASCII or UTF-8 format + var charset = mime.charsets.lookup(mimetype); + useBase64 = ['US-ASCII', 'UTF-8'].indexOf(charset) < 0; + if (useBase64) mimetype += ';base64'; + */ + + $mimetype = Less_Mime::lookup($filePath); + + $charset = Less_Mime::charsets_lookup($mimetype); + $useBase64 = !in_array($charset,array('US-ASCII', 'UTF-8')); + if( $useBase64 ){ $mimetype .= ';base64'; } + + }else{ + $useBase64 = preg_match('/;base64$/',$mimetype); + } + + + if( file_exists($filePath) ){ + $buf = @file_get_contents($filePath); + }else{ + $buf = false; + } + + + // IE8 cannot handle a data-uri larger than 32KB. If this is exceeded + // and the --ieCompat flag is enabled, return a normal url() instead. + $DATA_URI_MAX_KB = 32; + $fileSizeInKB = round( strlen($buf) / 1024 ); + if( $fileSizeInKB >= $DATA_URI_MAX_KB ){ + $url = new Less_Tree_Url( ($filePathNode ? $filePathNode : $mimetypeNode), $this->currentFileInfo); + return $url->compile($this); + } + + if( $buf ){ + $buf = $useBase64 ? base64_encode($buf) : rawurlencode($buf); + $filePath = '"data:' . $mimetype . ',' . $buf . '"'; + } + + return new Less_Tree_Url( new Less_Tree_Anonymous($filePath) ); + } + + //svg-gradient + public function svggradient( $direction ){ + + $throw_message = 'svg-gradient expects direction, start_color [start_position], [color position,]..., end_color [end_position]'; + $arguments = func_get_args(); + + if( count($arguments) < 3 ){ + throw new Less_Exception_Compiler( $throw_message ); + } + + $stops = array_slice($arguments,1); + $gradientType = 'linear'; + $rectangleDimension = 'x="0" y="0" width="1" height="1"'; + $useBase64 = true; + $directionValue = $direction->toCSS(); + + + switch( $directionValue ){ + case "to bottom": + $gradientDirectionSvg = 'x1="0%" y1="0%" x2="0%" y2="100%"'; + break; + case "to right": + $gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="0%"'; + break; + case "to bottom right": + $gradientDirectionSvg = 'x1="0%" y1="0%" x2="100%" y2="100%"'; + break; + case "to top right": + $gradientDirectionSvg = 'x1="0%" y1="100%" x2="100%" y2="0%"'; + break; + case "ellipse": + case "ellipse at center": + $gradientType = "radial"; + $gradientDirectionSvg = 'cx="50%" cy="50%" r="75%"'; + $rectangleDimension = 'x="-50" y="-50" width="101" height="101"'; + break; + default: + throw new Less_Exception_Compiler( "svg-gradient direction must be 'to bottom', 'to right', 'to bottom right', 'to top right' or 'ellipse at center'" ); + } + + $returner = '<?xml version="1.0" ?>' . + '<svg xmlns="http://www.w3.org/2000/svg" version="1.1" width="100%" height="100%" viewBox="0 0 1 1" preserveAspectRatio="none">' . + '<' . $gradientType . 'Gradient id="gradient" gradientUnits="userSpaceOnUse" ' . $gradientDirectionSvg . '>'; + + for( $i = 0; $i < count($stops); $i++ ){ + if( is_object($stops[$i]) && property_exists($stops[$i],'value') ){ + $color = $stops[$i]->value[0]; + $position = $stops[$i]->value[1]; + }else{ + $color = $stops[$i]; + $position = null; + } + + if( !($color instanceof Less_Tree_Color) || (!(($i === 0 || $i+1 === count($stops)) && $position === null) && !($position instanceof Less_Tree_Dimension)) ){ + throw new Less_Exception_Compiler( $throw_message ); + } + if( $position ){ + $positionValue = $position->toCSS(); + }elseif( $i === 0 ){ + $positionValue = '0%'; + }else{ + $positionValue = '100%'; + } + $alpha = $color->alpha; + $returner .= '<stop offset="' . $positionValue . '" stop-color="' . $color->toRGB() . '"' . ($alpha < 1 ? ' stop-opacity="' . $alpha . '"' : '') . '/>'; + } + + $returner .= '</' . $gradientType . 'Gradient><rect ' . $rectangleDimension . ' fill="url(#gradient)" /></svg>'; + + + if( $useBase64 ){ + $returner = "'data:image/svg+xml;base64,".base64_encode($returner)."'"; + }else{ + $returner = "'data:image/svg+xml,".$returner."'"; + } + + return new Less_Tree_URL( new Less_Tree_Anonymous( $returner ) ); + } + + + /** + * Php version of javascript's `encodeURIComponent` function + * + * @param string $string The string to encode + * @return string The encoded string + */ + public static function encodeURIComponent($string){ + $revert = array('%21' => '!', '%2A' => '*', '%27' => "'", '%28' => '(', '%29' => ')'); + return strtr(rawurlencode($string), $revert); + } + + + // Color Blending + // ref: http://www.w3.org/TR/compositing-1 + + public function colorBlend( $mode, $color1, $color2 ){ + $ab = $color1->alpha; // backdrop + $as = $color2->alpha; // source + $r = array(); // result + + $ar = $as + $ab * (1 - $as); + for( $i = 0; $i < 3; $i++ ){ + $cb = $color1->rgb[$i] / 255; + $cs = $color2->rgb[$i] / 255; + $cr = call_user_func( $mode, $cb, $cs ); + if( $ar ){ + $cr = ($as * $cs + $ab * ($cb - $as * ($cb + $cs - $cr))) / $ar; + } + $r[$i] = $cr * 255; + } + + return new Less_Tree_Color($r, $ar); + } + + public function multiply($color1 = null, $color2 = null ){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to multiply must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to multiply must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendMultiply'), $color1, $color2 ); + } + + private function colorBlendMultiply($cb, $cs){ + return $cb * $cs; + } + + public function screen($color1 = null, $color2 = null ){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to screen must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to screen must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendScreen'), $color1, $color2 ); + } + + private function colorBlendScreen( $cb, $cs){ + return $cb + $cs - $cb * $cs; + } + + public function overlay($color1 = null, $color2 = null){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to overlay must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to overlay must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendOverlay'), $color1, $color2 ); + } + + private function colorBlendOverlay($cb, $cs ){ + $cb *= 2; + return ($cb <= 1) + ? $this->colorBlendMultiply($cb, $cs) + : $this->colorBlendScreen($cb - 1, $cs); + } + + public function softlight($color1 = null, $color2 = null){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to softlight must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to softlight must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendSoftlight'), $color1, $color2 ); + } + + private function colorBlendSoftlight($cb, $cs ){ + $d = 1; + $e = $cb; + if( $cs > 0.5 ){ + $e = 1; + $d = ($cb > 0.25) ? sqrt($cb) + : ((16 * $cb - 12) * $cb + 4) * $cb; + } + return $cb - (1 - 2 * $cs) * $e * ($d - $cb); + } + + public function hardlight($color1 = null, $color2 = null){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to hardlight must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to hardlight must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendHardlight'), $color1, $color2 ); + } + + private function colorBlendHardlight( $cb, $cs ){ + return $this->colorBlendOverlay($cs, $cb); + } + + public function difference($color1 = null, $color2 = null) { + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to difference must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to difference must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendDifference'), $color1, $color2 ); + } + + private function colorBlendDifference( $cb, $cs ){ + return abs($cb - $cs); + } + + public function exclusion( $color1 = null, $color2 = null ){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to exclusion must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to exclusion must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendExclusion'), $color1, $color2 ); + } + + private function colorBlendExclusion( $cb, $cs ){ + return $cb + $cs - 2 * $cb * $cs; + } + + public function average($color1 = null, $color2 = null){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to average must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to average must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendAverage'), $color1, $color2 ); + } + + // non-w3c functions: + public function colorBlendAverage($cb, $cs ){ + return ($cb + $cs) / 2; + } + + public function negation($color1 = null, $color2 = null ){ + if (!$color1 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The first argument to negation must be a color' . ($color1 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + if (!$color2 instanceof Less_Tree_Color) { + throw new Less_Exception_Compiler('The second argument to negation must be a color' . ($color2 instanceof Less_Tree_Expression ? ' (did you forgot commas?)' : '') ); + } + + return $this->colorBlend( array($this,'colorBlendNegation'), $color1, $color2 ); + } + + public function colorBlendNegation($cb, $cs){ + return 1 - abs($cb + $cs - 1); + } + + // ~ End of Color Blending + +} + + +/** + * Mime lookup + * + * @package Less + * @subpackage node + */ +class Less_Mime{ + + // this map is intentionally incomplete + // if you want more, install 'mime' dep + static $_types = array( + '.htm' => 'text/html', + '.html'=> 'text/html', + '.gif' => 'image/gif', + '.jpg' => 'image/jpeg', + '.jpeg'=> 'image/jpeg', + '.png' => 'image/png', + '.ttf' => 'application/x-font-ttf', + '.otf' => 'application/x-font-otf', + '.eot' => 'application/vnd.ms-fontobject', + '.woff' => 'application/x-font-woff', + '.svg' => 'image/svg+xml', + ); + + public static function lookup( $filepath ){ + $parts = explode('.',$filepath); + $ext = '.'.strtolower(array_pop($parts)); + + if( !isset(self::$_types[$ext]) ){ + return null; + } + return self::$_types[$ext]; + } + + public static function charsets_lookup( $type = null ){ + // assumes all text types are UTF-8 + return $type && preg_match('/^text\//',$type) ? 'UTF-8' : ''; + } +} + + +/** + * Tree + * + * @package Less + * @subpackage tree + */ +class Less_Tree{ + + public $cache_string; + + public function toCSS(){ + $output = new Less_Output(); + $this->genCSS($output); + return $output->toString(); + } + + + /** + * Generate CSS by adding it to the output object + * + * @param Less_Output $output The output + * @return void + */ + public function genCSS($output){} + + + /** + * @param Less_Tree_Ruleset[] $rules + */ + public static function outputRuleset( $output, $rules ){ + + $ruleCnt = count($rules); + Less_Environment::$tabLevel++; + + + // Compressed + if( Less_Parser::$options['compress'] ){ + $output->add('{'); + for( $i = 0; $i < $ruleCnt; $i++ ){ + $rules[$i]->genCSS( $output ); + } + + $output->add( '}' ); + Less_Environment::$tabLevel--; + return; + } + + + // Non-compressed + $tabSetStr = "\n".str_repeat( Less_Parser::$options['indentation'] , Less_Environment::$tabLevel-1 ); + $tabRuleStr = $tabSetStr.Less_Parser::$options['indentation']; + + $output->add( " {" ); + for($i = 0; $i < $ruleCnt; $i++ ){ + $output->add( $tabRuleStr ); + $rules[$i]->genCSS( $output ); + } + Less_Environment::$tabLevel--; + $output->add( $tabSetStr.'}' ); + + } + + public function accept($visitor){} + + + public static function ReferencedArray($rules){ + foreach($rules as $rule){ + if( method_exists($rule, 'markReferenced') ){ + $rule->markReferenced(); + } + } + } + + + /** + * Requires php 5.3+ + */ + public static function __set_state($args){ + + $class = get_called_class(); + $obj = new $class(null,null,null,null); + foreach($args as $key => $val){ + $obj->$key = $val; + } + return $obj; + } + +} + + +/** + * Parser output + * + * @package Less + * @subpackage output + */ +class Less_Output{ + + /** + * Output holder + * + * @var string + */ + protected $strs = array(); + + /** + * Adds a chunk to the stack + * + * @param string $chunk The chunk to output + * @param Less_FileInfo $fileInfo The file information + * @param integer $index The index + * @param mixed $mapLines + */ + public function add($chunk, $fileInfo = null, $index = 0, $mapLines = null){ + $this->strs[] = $chunk; + } + + /** + * Is the output empty? + * + * @return boolean + */ + public function isEmpty(){ + return count($this->strs) === 0; + } + + + /** + * Converts the output to string + * + * @return string + */ + public function toString(){ + return implode('',$this->strs); + } + +} + +/** + * Visitor + * + * @package Less + * @subpackage visitor + */ +class Less_Visitor{ + + protected $methods = array(); + protected $_visitFnCache = array(); + + public function __construct(){ + $this->_visitFnCache = get_class_methods(get_class($this)); + $this->_visitFnCache = array_flip($this->_visitFnCache); + } + + public function visitObj( $node ){ + + $funcName = 'visit'.$node->type; + if( isset($this->_visitFnCache[$funcName]) ){ + + $visitDeeper = true; + $this->$funcName( $node, $visitDeeper ); + + if( $visitDeeper ){ + $node->accept($this); + } + + $funcName = $funcName . "Out"; + if( isset($this->_visitFnCache[$funcName]) ){ + $this->$funcName( $node ); + } + + }else{ + $node->accept($this); + } + + return $node; + } + + public function visitArray( $nodes ){ + + array_map( array($this,'visitObj'), $nodes); + return $nodes; + } +} + + + +/** + * Replacing Visitor + * + * @package Less + * @subpackage visitor + */ +class Less_VisitorReplacing extends Less_Visitor{ + + public function visitObj( $node ){ + + $funcName = 'visit'.$node->type; + if( isset($this->_visitFnCache[$funcName]) ){ + + $visitDeeper = true; + $node = $this->$funcName( $node, $visitDeeper ); + + if( $node ){ + if( $visitDeeper && is_object($node) ){ + $node->accept($this); + } + + $funcName = $funcName . "Out"; + if( isset($this->_visitFnCache[$funcName]) ){ + $this->$funcName( $node ); + } + } + + }else{ + $node->accept($this); + } + + return $node; + } + + public function visitArray( $nodes ){ + + $newNodes = array(); + foreach($nodes as $node){ + $evald = $this->visitObj($node); + if( $evald ){ + if( is_array($evald) ){ + self::flatten($evald,$newNodes); + }else{ + $newNodes[] = $evald; + } + } + } + return $newNodes; + } + + public function flatten( $arr, &$out ){ + + foreach($arr as $item){ + if( !is_array($item) ){ + $out[] = $item; + continue; + } + + foreach($item as $nestedItem){ + if( is_array($nestedItem) ){ + self::flatten( $nestedItem, $out); + }else{ + $out[] = $nestedItem; + } + } + } + + return $out; + } + +} + + + + +/** + * Configurable + * + * @package Less + * @subpackage Core + */ +abstract class Less_Configurable { + + /** + * Array of options + * + * @var array + */ + protected $options = array(); + + /** + * Array of default options + * + * @var array + */ + protected $defaultOptions = array(); + + + /** + * Set options + * + * If $options is an object it will be converted into an array by called + * it's toArray method. + * + * @throws Exception + * @param array|object $options + * + */ + public function setOptions($options){ + $options = array_intersect_key($options,$this->defaultOptions); + $this->options = array_merge($this->defaultOptions, $this->options, $options); + } + + + /** + * Get an option value by name + * + * If the option is empty or not set a NULL value will be returned. + * + * @param string $name + * @param mixed $default Default value if confiuration of $name is not present + * @return mixed + */ + public function getOption($name, $default = null){ + if(isset($this->options[$name])){ + return $this->options[$name]; + } + return $default; + } + + + /** + * Set an option + * + * @param string $name + * @param mixed $value + */ + public function setOption($name, $value){ + $this->options[$name] = $value; + } + +} + +/** + * Alpha + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Alpha extends Less_Tree{ + public $value; + public $type = 'Alpha'; + + public function __construct($val){ + $this->value = $val; + } + + //function accept( $visitor ){ + // $this->value = $visitor->visit( $this->value ); + //} + + public function compile($env){ + + if( is_object($this->value) ){ + $this->value = $this->value->compile($env); + } + + return $this; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + $output->add( "alpha(opacity=" ); + + if( is_string($this->value) ){ + $output->add( $this->value ); + }else{ + $this->value->genCSS( $output); + } + + $output->add( ')' ); + } + + public function toCSS(){ + return "alpha(opacity=" . (is_string($this->value) ? $this->value : $this->value->toCSS()) . ")"; + } + + +} + +/** + * Anonymous + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Anonymous extends Less_Tree{ + public $value; + public $quote; + public $index; + public $mapLines; + public $currentFileInfo; + public $type = 'Anonymous'; + + /** + * @param integer $index + * @param boolean $mapLines + */ + public function __construct($value, $index = null, $currentFileInfo = null, $mapLines = null ){ + $this->value = $value; + $this->index = $index; + $this->mapLines = $mapLines; + $this->currentFileInfo = $currentFileInfo; + } + + public function compile(){ + return new Less_Tree_Anonymous($this->value, $this->index, $this->currentFileInfo, $this->mapLines); + } + + public function compare($x){ + if( !is_object($x) ){ + return -1; + } + + $left = $this->toCSS(); + $right = $x->toCSS(); + + if( $left === $right ){ + return 0; + } + + return $left < $right ? -1 : 1; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( $this->value, $this->currentFileInfo, $this->index, $this->mapLines ); + } + + public function toCSS(){ + return $this->value; + } + +} + + +/** + * Assignment + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Assignment extends Less_Tree{ + + public $key; + public $value; + public $type = 'Assignment'; + + public function __construct($key, $val) { + $this->key = $key; + $this->value = $val; + } + + public function accept( $visitor ){ + $this->value = $visitor->visitObj( $this->value ); + } + + public function compile($env) { + return new Less_Tree_Assignment( $this->key, $this->value->compile($env)); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( $this->key . '=' ); + $this->value->genCSS( $output ); + } + + public function toCss(){ + return $this->key . '=' . $this->value->toCSS(); + } +} + + +/** + * Attribute + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Attribute extends Less_Tree{ + + public $key; + public $op; + public $value; + public $type = 'Attribute'; + + public function __construct($key, $op, $value){ + $this->key = $key; + $this->op = $op; + $this->value = $value; + } + + public function compile($env){ + + $key_obj = is_object($this->key); + $val_obj = is_object($this->value); + + if( !$key_obj && !$val_obj ){ + return $this; + } + + return new Less_Tree_Attribute( + $key_obj ? $this->key->compile($env) : $this->key , + $this->op, + $val_obj ? $this->value->compile($env) : $this->value); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( $this->toCSS() ); + } + + public function toCSS(){ + $value = $this->key; + + if( $this->op ){ + $value .= $this->op; + $value .= (is_object($this->value) ? $this->value->toCSS() : $this->value); + } + + return '[' . $value . ']'; + } +} + + +/** + * Call + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Call extends Less_Tree{ + public $value; + + protected $name; + protected $args; + protected $index; + protected $currentFileInfo; + public $type = 'Call'; + + public function __construct($name, $args, $index, $currentFileInfo = null ){ + $this->name = $name; + $this->args = $args; + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + } + + public function accept( $visitor ){ + $this->args = $visitor->visitArray( $this->args ); + } + + // + // When evaluating a function call, + // we either find the function in `tree.functions` [1], + // in which case we call it, passing the evaluated arguments, + // or we simply print it out as it appeared originally [2]. + // + // The *functions.js* file contains the built-in functions. + // + // The reason why we evaluate the arguments, is in the case where + // we try to pass a variable to a function, like: `saturate(@color)`. + // The function should receive the value, not the variable. + // + public function compile($env=null){ + $args = array(); + foreach($this->args as $a){ + $args[] = $a->compile($env); + } + + $nameLC = strtolower($this->name); + switch($nameLC){ + case '%': + $nameLC = '_percent'; + break; + + case 'get-unit': + $nameLC = 'getunit'; + break; + + case 'data-uri': + $nameLC = 'datauri'; + break; + + case 'svg-gradient': + $nameLC = 'svggradient'; + break; + } + + $result = null; + if( $nameLC === 'default' ){ + $result = Less_Tree_DefaultFunc::compile(); + + }else{ + + if( method_exists('Less_Functions',$nameLC) ){ // 1. + try { + + $func = new Less_Functions($env, $this->currentFileInfo); + $result = call_user_func_array( array($func,$nameLC),$args); + + } catch (Exception $e) { + throw new Less_Exception_Compiler('error evaluating function `' . $this->name . '` '.$e->getMessage().' index: '. $this->index); + } + } elseif( isset( $env->functions[$nameLC] ) && is_callable( $env->functions[$nameLC] ) ) { + try { + $result = call_user_func_array( $env->functions[$nameLC], $args ); + } catch (Exception $e) { + throw new Less_Exception_Compiler('error evaluating function `' . $this->name . '` '.$e->getMessage().' index: '. $this->index); + } + } + } + + if( $result !== null ){ + return $result; + } + + + return new Less_Tree_Call( $this->name, $args, $this->index, $this->currentFileInfo ); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + $output->add( $this->name . '(', $this->currentFileInfo, $this->index ); + $args_len = count($this->args); + for($i = 0; $i < $args_len; $i++ ){ + $this->args[$i]->genCSS( $output ); + if( $i + 1 < $args_len ){ + $output->add( ', ' ); + } + } + + $output->add( ')' ); + } + + + //public function toCSS(){ + // return $this->compile()->toCSS(); + //} + +} + + +/** + * Color + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Color extends Less_Tree{ + public $rgb; + public $alpha; + public $isTransparentKeyword; + public $type = 'Color'; + + public function __construct($rgb, $a = 1, $isTransparentKeyword = null ){ + + if( $isTransparentKeyword ){ + $this->rgb = $rgb; + $this->alpha = $a; + $this->isTransparentKeyword = true; + return; + } + + $this->rgb = array(); + if( is_array($rgb) ){ + $this->rgb = $rgb; + }else if( strlen($rgb) == 6 ){ + foreach(str_split($rgb, 2) as $c){ + $this->rgb[] = hexdec($c); + } + }else{ + foreach(str_split($rgb, 1) as $c){ + $this->rgb[] = hexdec($c.$c); + } + } + $this->alpha = is_numeric($a) ? $a : 1; + } + + public function compile(){ + return $this; + } + + public function luma(){ + $r = $this->rgb[0] / 255; + $g = $this->rgb[1] / 255; + $b = $this->rgb[2] / 255; + + $r = ($r <= 0.03928) ? $r / 12.92 : pow((($r + 0.055) / 1.055), 2.4); + $g = ($g <= 0.03928) ? $g / 12.92 : pow((($g + 0.055) / 1.055), 2.4); + $b = ($b <= 0.03928) ? $b / 12.92 : pow((($b + 0.055) / 1.055), 2.4); + + return 0.2126 * $r + 0.7152 * $g + 0.0722 * $b; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( $this->toCSS() ); + } + + public function toCSS( $doNotCompress = false ){ + $compress = Less_Parser::$options['compress'] && !$doNotCompress; + $alpha = Less_Functions::fround( $this->alpha ); + + + // + // If we have some transparency, the only way to represent it + // is via `rgba`. Otherwise, we use the hex representation, + // which has better compatibility with older browsers. + // Values are capped between `0` and `255`, rounded and zero-padded. + // + if( $alpha < 1 ){ + if( ( $alpha === 0 || $alpha === 0.0 ) && isset($this->isTransparentKeyword) && $this->isTransparentKeyword ){ + return 'transparent'; + } + + $values = array(); + foreach($this->rgb as $c){ + $values[] = Less_Functions::clamp( round($c), 255); + } + $values[] = $alpha; + + $glue = ($compress ? ',' : ', '); + return "rgba(" . implode($glue, $values) . ")"; + }else{ + + $color = $this->toRGB(); + + if( $compress ){ + + // Convert color to short format + if( $color[1] === $color[2] && $color[3] === $color[4] && $color[5] === $color[6]) { + $color = '#'.$color[1] . $color[3] . $color[5]; + } + } + + return $color; + } + } + + // + // Operations have to be done per-channel, if not, + // channels will spill onto each other. Once we have + // our result, in the form of an integer triplet, + // we create a new Color node to hold the result. + // + + /** + * @param string $op + */ + public function operate( $op, $other) { + $rgb = array(); + $alpha = $this->alpha * (1 - $other->alpha) + $other->alpha; + for ($c = 0; $c < 3; $c++) { + $rgb[$c] = Less_Functions::operate( $op, $this->rgb[$c], $other->rgb[$c]); + } + return new Less_Tree_Color($rgb, $alpha); + } + + public function toRGB(){ + return $this->toHex($this->rgb); + } + + public function toHSL(){ + $r = $this->rgb[0] / 255; + $g = $this->rgb[1] / 255; + $b = $this->rgb[2] / 255; + $a = $this->alpha; + + $max = max($r, $g, $b); + $min = min($r, $g, $b); + $l = ($max + $min) / 2; + $d = $max - $min; + + $h = $s = 0; + if( $max !== $min ){ + $s = $l > 0.5 ? $d / (2 - $max - $min) : $d / ($max + $min); + + switch ($max) { + case $r: $h = ($g - $b) / $d + ($g < $b ? 6 : 0); break; + case $g: $h = ($b - $r) / $d + 2; break; + case $b: $h = ($r - $g) / $d + 4; break; + } + $h /= 6; + } + return array('h' => $h * 360, 's' => $s, 'l' => $l, 'a' => $a ); + } + + //Adapted from http://mjijackson.com/2008/02/rgb-to-hsl-and-rgb-to-hsv-color-model-conversion-algorithms-in-javascript + public function toHSV() { + $r = $this->rgb[0] / 255; + $g = $this->rgb[1] / 255; + $b = $this->rgb[2] / 255; + $a = $this->alpha; + + $max = max($r, $g, $b); + $min = min($r, $g, $b); + + $v = $max; + + $d = $max - $min; + if ($max === 0) { + $s = 0; + } else { + $s = $d / $max; + } + + $h = 0; + if( $max !== $min ){ + switch($max){ + case $r: $h = ($g - $b) / $d + ($g < $b ? 6 : 0); break; + case $g: $h = ($b - $r) / $d + 2; break; + case $b: $h = ($r - $g) / $d + 4; break; + } + $h /= 6; + } + return array('h'=> $h * 360, 's'=> $s, 'v'=> $v, 'a' => $a ); + } + + public function toARGB(){ + $argb = array_merge( (array) Less_Parser::round($this->alpha * 255), $this->rgb); + return $this->toHex( $argb ); + } + + public function compare($x){ + + if( !property_exists( $x, 'rgb' ) ){ + return -1; + } + + + return ($x->rgb[0] === $this->rgb[0] && + $x->rgb[1] === $this->rgb[1] && + $x->rgb[2] === $this->rgb[2] && + $x->alpha === $this->alpha) ? 0 : -1; + } + + public function toHex( $v ){ + + $ret = '#'; + foreach($v as $c){ + $c = Less_Functions::clamp( Less_Parser::round($c), 255); + if( $c < 16 ){ + $ret .= '0'; + } + $ret .= dechex($c); + } + + return $ret; + } + + + /** + * @param string $keyword + */ + public static function fromKeyword( $keyword ){ + $keyword = strtolower($keyword); + + if( Less_Colors::hasOwnProperty($keyword) ){ + // detect named color + return new Less_Tree_Color(substr(Less_Colors::color($keyword), 1)); + } + + if( $keyword === 'transparent' ){ + return new Less_Tree_Color( array(0, 0, 0), 0, true); + } + } + +} + + +/** + * Comment + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Comment extends Less_Tree{ + + public $value; + public $silent; + public $isReferenced; + public $currentFileInfo; + public $type = 'Comment'; + + public function __construct($value, $silent, $index = null, $currentFileInfo = null ){ + $this->value = $value; + $this->silent = !! $silent; + $this->currentFileInfo = $currentFileInfo; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + //if( $this->debugInfo ){ + //$output->add( tree.debugInfo($env, $this), $this->currentFileInfo, $this->index); + //} + $output->add( trim($this->value) );//TODO shouldn't need to trim, we shouldn't grab the \n + } + + public function toCSS(){ + return Less_Parser::$options['compress'] ? '' : $this->value; + } + + public function isSilent(){ + $isReference = ($this->currentFileInfo && isset($this->currentFileInfo['reference']) && (!isset($this->isReferenced) || !$this->isReferenced) ); + $isCompressed = Less_Parser::$options['compress'] && !preg_match('/^\/\*!/', $this->value); + return $this->silent || $isReference || $isCompressed; + } + + public function compile(){ + return $this; + } + + public function markReferenced(){ + $this->isReferenced = true; + } + +} + + +/** + * Condition + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Condition extends Less_Tree{ + + public $op; + public $lvalue; + public $rvalue; + public $index; + public $negate; + public $type = 'Condition'; + + public function __construct($op, $l, $r, $i = 0, $negate = false) { + $this->op = trim($op); + $this->lvalue = $l; + $this->rvalue = $r; + $this->index = $i; + $this->negate = $negate; + } + + public function accept($visitor){ + $this->lvalue = $visitor->visitObj( $this->lvalue ); + $this->rvalue = $visitor->visitObj( $this->rvalue ); + } + + public function compile($env) { + $a = $this->lvalue->compile($env); + $b = $this->rvalue->compile($env); + + switch( $this->op ){ + case 'and': + $result = $a && $b; + break; + + case 'or': + $result = $a || $b; + break; + + default: + if( Less_Parser::is_method($a, 'compare') ){ + $result = $a->compare($b); + }elseif( Less_Parser::is_method($b, 'compare') ){ + $result = $b->compare($a); + }else{ + throw new Less_Exception_Compiler('Unable to perform comparison', null, $this->index); + } + + switch ($result) { + case -1: + $result = $this->op === '<' || $this->op === '=<' || $this->op === '<='; + break; + + case 0: + $result = $this->op === '=' || $this->op === '>=' || $this->op === '=<' || $this->op === '<='; + break; + + case 1: + $result = $this->op === '>' || $this->op === '>='; + break; + } + break; + } + + return $this->negate ? !$result : $result; + } + +} + + +/** + * DefaultFunc + * + * @package Less + * @subpackage tree + */ +class Less_Tree_DefaultFunc{ + + static $error_; + static $value_; + + public static function compile(){ + if( self::$error_ ){ + throw new Exception(self::$error_); + } + if( self::$value_ !== null ){ + return self::$value_ ? new Less_Tree_Keyword('true') : new Less_Tree_Keyword('false'); + } + } + + public static function value( $v ){ + self::$value_ = $v; + } + + public static function error( $e ){ + self::$error_ = $e; + } + + public static function reset(){ + self::$value_ = self::$error_ = null; + } +} + +/** + * DetachedRuleset + * + * @package Less + * @subpackage tree + */ +class Less_Tree_DetachedRuleset extends Less_Tree{ + + public $ruleset; + public $frames; + public $type = 'DetachedRuleset'; + + public function __construct( $ruleset, $frames = null ){ + $this->ruleset = $ruleset; + $this->frames = $frames; + } + + public function accept($visitor) { + $this->ruleset = $visitor->visitObj($this->ruleset); + } + + public function compile($env){ + if( $this->frames ){ + $frames = $this->frames; + }else{ + $frames = $env->frames; + } + return new Less_Tree_DetachedRuleset($this->ruleset, $frames); + } + + public function callEval($env) { + if( $this->frames ){ + return $this->ruleset->compile( $env->copyEvalEnv( array_merge($this->frames,$env->frames) ) ); + } + return $this->ruleset->compile( $env ); + } +} + + + +/** + * Dimension + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Dimension extends Less_Tree{ + + public $value; + public $unit; + public $type = 'Dimension'; + + public function __construct($value, $unit = null){ + $this->value = floatval($value); + + if( $unit && ($unit instanceof Less_Tree_Unit) ){ + $this->unit = $unit; + }elseif( $unit ){ + $this->unit = new Less_Tree_Unit( array($unit) ); + }else{ + $this->unit = new Less_Tree_Unit( ); + } + } + + public function accept( $visitor ){ + $this->unit = $visitor->visitObj( $this->unit ); + } + + public function compile(){ + return $this; + } + + public function toColor() { + return new Less_Tree_Color(array($this->value, $this->value, $this->value)); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + if( Less_Parser::$options['strictUnits'] && !$this->unit->isSingular() ){ + throw new Less_Exception_Compiler("Multiple units in dimension. Correct the units or use the unit function. Bad unit: ".$this->unit->toString()); + } + + $value = Less_Functions::fround( $this->value ); + $strValue = (string)$value; + + if( $value !== 0 && $value < 0.000001 && $value > -0.000001 ){ + // would be output 1e-6 etc. + $strValue = number_format($strValue,10); + $strValue = preg_replace('/\.?0+$/','', $strValue); + } + + if( Less_Parser::$options['compress'] ){ + // Zero values doesn't need a unit + if( $value === 0 && $this->unit->isLength() ){ + $output->add( $strValue ); + return $strValue; + } + + // Float values doesn't need a leading zero + if( $value > 0 && $value < 1 && $strValue[0] === '0' ){ + $strValue = substr($strValue,1); + } + } + + $output->add( $strValue ); + $this->unit->genCSS( $output ); + } + + public function __toString(){ + return $this->toCSS(); + } + + // In an operation between two Dimensions, + // we default to the first Dimension's unit, + // so `1px + 2em` will yield `3px`. + + /** + * @param string $op + */ + public function operate( $op, $other){ + + $value = Less_Functions::operate( $op, $this->value, $other->value); + $unit = clone $this->unit; + + if( $op === '+' || $op === '-' ){ + + if( !$unit->numerator && !$unit->denominator ){ + $unit->numerator = $other->unit->numerator; + $unit->denominator = $other->unit->denominator; + }elseif( !$other->unit->numerator && !$other->unit->denominator ){ + // do nothing + }else{ + $other = $other->convertTo( $this->unit->usedUnits()); + + if( Less_Parser::$options['strictUnits'] && $other->unit->toString() !== $unit->toCSS() ){ + throw new Less_Exception_Compiler("Incompatible units. Change the units or use the unit function. Bad units: '" . $unit->toString() . "' and " . $other->unit->toString() . "'."); + } + + $value = Less_Functions::operate( $op, $this->value, $other->value); + } + }elseif( $op === '*' ){ + $unit->numerator = array_merge($unit->numerator, $other->unit->numerator); + $unit->denominator = array_merge($unit->denominator, $other->unit->denominator); + sort($unit->numerator); + sort($unit->denominator); + $unit->cancel(); + }elseif( $op === '/' ){ + $unit->numerator = array_merge($unit->numerator, $other->unit->denominator); + $unit->denominator = array_merge($unit->denominator, $other->unit->numerator); + sort($unit->numerator); + sort($unit->denominator); + $unit->cancel(); + } + return new Less_Tree_Dimension( $value, $unit); + } + + public function compare($other) { + if ($other instanceof Less_Tree_Dimension) { + + if( $this->unit->isEmpty() || $other->unit->isEmpty() ){ + $a = $this; + $b = $other; + } else { + $a = $this->unify(); + $b = $other->unify(); + if( $a->unit->compare($b->unit) !== 0 ){ + return -1; + } + } + $aValue = $a->value; + $bValue = $b->value; + + if ($bValue > $aValue) { + return -1; + } elseif ($bValue < $aValue) { + return 1; + } else { + return 0; + } + } else { + return -1; + } + } + + public function unify() { + return $this->convertTo(array('length'=> 'px', 'duration'=> 's', 'angle' => 'rad' )); + } + + public function convertTo($conversions) { + $value = $this->value; + $unit = clone $this->unit; + + if( is_string($conversions) ){ + $derivedConversions = array(); + foreach( Less_Tree_UnitConversions::$groups as $i ){ + if( isset(Less_Tree_UnitConversions::${$i}[$conversions]) ){ + $derivedConversions = array( $i => $conversions); + } + } + $conversions = $derivedConversions; + } + + + foreach($conversions as $groupName => $targetUnit){ + $group = Less_Tree_UnitConversions::${$groupName}; + + //numerator + foreach($unit->numerator as $i => $atomicUnit){ + $atomicUnit = $unit->numerator[$i]; + if( !isset($group[$atomicUnit]) ){ + continue; + } + + $value = $value * ($group[$atomicUnit] / $group[$targetUnit]); + + $unit->numerator[$i] = $targetUnit; + } + + //denominator + foreach($unit->denominator as $i => $atomicUnit){ + $atomicUnit = $unit->denominator[$i]; + if( !isset($group[$atomicUnit]) ){ + continue; + } + + $value = $value / ($group[$atomicUnit] / $group[$targetUnit]); + + $unit->denominator[$i] = $targetUnit; + } + } + + $unit->cancel(); + + return new Less_Tree_Dimension( $value, $unit); + } +} + + +/** + * Directive + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Directive extends Less_Tree{ + + public $name; + public $value; + public $rules; + public $index; + public $isReferenced; + public $currentFileInfo; + public $debugInfo; + public $type = 'Directive'; + + public function __construct($name, $value = null, $rules, $index = null, $currentFileInfo = null, $debugInfo = null ){ + $this->name = $name; + $this->value = $value; + if( $rules ){ + $this->rules = $rules; + $this->rules->allowImports = true; + } + + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + $this->debugInfo = $debugInfo; + } + + + public function accept( $visitor ){ + if( $this->rules ){ + $this->rules = $visitor->visitObj( $this->rules ); + } + if( $this->value ){ + $this->value = $visitor->visitObj( $this->value ); + } + } + + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $value = $this->value; + $rules = $this->rules; + $output->add( $this->name, $this->currentFileInfo, $this->index ); + if( $this->value ){ + $output->add(' '); + $this->value->genCSS($output); + } + if( $this->rules ){ + Less_Tree::outputRuleset( $output, array($this->rules)); + } else { + $output->add(';'); + } + } + + public function compile($env){ + + $value = $this->value; + $rules = $this->rules; + if( $value ){ + $value = $value->compile($env); + } + + if( $rules ){ + $rules = $rules->compile($env); + $rules->root = true; + } + + return new Less_Tree_Directive( $this->name, $value, $rules, $this->index, $this->currentFileInfo, $this->debugInfo ); + } + + + public function variable($name){ + if( $this->rules ){ + return $this->rules->variable($name); + } + } + + public function find($selector){ + if( $this->rules ){ + return $this->rules->find($selector, $this); + } + } + + //rulesets: function () { if (this.rules) return tree.Ruleset.prototype.rulesets.apply(this.rules); }, + + public function markReferenced(){ + $this->isReferenced = true; + if( $this->rules ){ + Less_Tree::ReferencedArray($this->rules->rules); + } + } + +} + + +/** + * Element + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Element extends Less_Tree{ + + public $combinator = ''; + public $value = ''; + public $index; + public $currentFileInfo; + public $type = 'Element'; + + public $value_is_object = false; + + public function __construct($combinator, $value, $index = null, $currentFileInfo = null ){ + + $this->value = $value; + $this->value_is_object = is_object($value); + + if( $combinator ){ + $this->combinator = $combinator; + } + + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + } + + public function accept( $visitor ){ + if( $this->value_is_object ){ //object or string + $this->value = $visitor->visitObj( $this->value ); + } + } + + public function compile($env){ + + if( Less_Environment::$mixin_stack ){ + return new Less_Tree_Element($this->combinator, ($this->value_is_object ? $this->value->compile($env) : $this->value), $this->index, $this->currentFileInfo ); + } + + if( $this->value_is_object ){ + $this->value = $this->value->compile($env); + } + + return $this; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( $this->toCSS(), $this->currentFileInfo, $this->index ); + } + + public function toCSS(){ + + if( $this->value_is_object ){ + $value = $this->value->toCSS(); + }else{ + $value = $this->value; + } + + + if( $value === '' && $this->combinator && $this->combinator === '&' ){ + return ''; + } + + + return Less_Environment::$_outputMap[$this->combinator] . $value; + } + +} + + +/** + * Expression + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Expression extends Less_Tree{ + + public $value = array(); + public $parens = false; + public $parensInOp = false; + public $type = 'Expression'; + + public function __construct( $value, $parens = null ){ + $this->value = $value; + $this->parens = $parens; + } + + public function accept( $visitor ){ + $this->value = $visitor->visitArray( $this->value ); + } + + public function compile($env) { + + $doubleParen = false; + + if( $this->parens && !$this->parensInOp ){ + Less_Environment::$parensStack++; + } + + $returnValue = null; + if( $this->value ){ + + $count = count($this->value); + + if( $count > 1 ){ + + $ret = array(); + foreach($this->value as $e){ + $ret[] = $e->compile($env); + } + $returnValue = new Less_Tree_Expression($ret); + + }else{ + + if( ($this->value[0] instanceof Less_Tree_Expression) && $this->value[0]->parens && !$this->value[0]->parensInOp ){ + $doubleParen = true; + } + + $returnValue = $this->value[0]->compile($env); + } + + } else { + $returnValue = $this; + } + + if( $this->parens ){ + if( !$this->parensInOp ){ + Less_Environment::$parensStack--; + + }elseif( !Less_Environment::isMathOn() && !$doubleParen ){ + $returnValue = new Less_Tree_Paren($returnValue); + + } + } + return $returnValue; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $val_len = count($this->value); + for( $i = 0; $i < $val_len; $i++ ){ + $this->value[$i]->genCSS( $output ); + if( $i + 1 < $val_len ){ + $output->add( ' ' ); + } + } + } + + public function throwAwayComments() { + + if( is_array($this->value) ){ + $new_value = array(); + foreach($this->value as $v){ + if( $v instanceof Less_Tree_Comment ){ + continue; + } + $new_value[] = $v; + } + $this->value = $new_value; + } + } +} + + +/** + * Extend + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Extend extends Less_Tree{ + + public $selector; + public $option; + public $index; + public $selfSelectors = array(); + public $allowBefore; + public $allowAfter; + public $firstExtendOnThisSelectorPath; + public $type = 'Extend'; + public $ruleset; + + + public $object_id; + public $parent_ids = array(); + + /** + * @param integer $index + */ + public function __construct($selector, $option, $index){ + static $i = 0; + $this->selector = $selector; + $this->option = $option; + $this->index = $index; + + switch($option){ + case "all": + $this->allowBefore = true; + $this->allowAfter = true; + break; + default: + $this->allowBefore = false; + $this->allowAfter = false; + break; + } + + $this->object_id = $i++; + $this->parent_ids = array($this->object_id); + } + + public function accept( $visitor ){ + $this->selector = $visitor->visitObj( $this->selector ); + } + + public function compile( $env ){ + Less_Parser::$has_extends = true; + $this->selector = $this->selector->compile($env); + return $this; + //return new Less_Tree_Extend( $this->selector->compile($env), $this->option, $this->index); + } + + public function findSelfSelectors( $selectors ){ + $selfElements = array(); + + + for( $i = 0, $selectors_len = count($selectors); $i < $selectors_len; $i++ ){ + $selectorElements = $selectors[$i]->elements; + // duplicate the logic in genCSS function inside the selector node. + // future TODO - move both logics into the selector joiner visitor + if( $i && $selectorElements && $selectorElements[0]->combinator === "") { + $selectorElements[0]->combinator = ' '; + } + $selfElements = array_merge( $selfElements, $selectors[$i]->elements ); + } + + $this->selfSelectors = array(new Less_Tree_Selector($selfElements)); + } + +} + +/** + * CSS @import node + * + * The general strategy here is that we don't want to wait + * for the parsing to be completed, before we start importing + * the file. That's because in the context of a browser, + * most of the time will be spent waiting for the server to respond. + * + * On creation, we push the import path to our import queue, though + * `import,push`, we also pass it a callback, which it'll call once + * the file has been fetched, and parsed. + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Import extends Less_Tree{ + + public $options; + public $index; + public $path; + public $features; + public $currentFileInfo; + public $css; + public $skip; + public $root; + public $type = 'Import'; + + public function __construct($path, $features, $options, $index, $currentFileInfo = null ){ + $this->options = $options; + $this->index = $index; + $this->path = $path; + $this->features = $features; + $this->currentFileInfo = $currentFileInfo; + + if( is_array($options) ){ + $this->options += array('inline'=>false); + + if( isset($this->options['less']) || $this->options['inline'] ){ + $this->css = !isset($this->options['less']) || !$this->options['less'] || $this->options['inline']; + } else { + $pathValue = $this->getPath(); + if( $pathValue && preg_match('/css([\?;].*)?$/',$pathValue) ){ + $this->css = true; + } + } + } + } + +// +// The actual import node doesn't return anything, when converted to CSS. +// The reason is that it's used at the evaluation stage, so that the rules +// it imports can be treated like any other rules. +// +// In `eval`, we make sure all Import nodes get evaluated, recursively, so +// we end up with a flat structure, which can easily be imported in the parent +// ruleset. +// + + public function accept($visitor){ + + if( $this->features ){ + $this->features = $visitor->visitObj($this->features); + } + $this->path = $visitor->visitObj($this->path); + + if( !$this->options['inline'] && $this->root ){ + $this->root = $visitor->visit($this->root); + } + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + if( $this->css ){ + + $output->add( '@import ', $this->currentFileInfo, $this->index ); + + $this->path->genCSS( $output ); + if( $this->features ){ + $output->add( ' ' ); + $this->features->genCSS( $output ); + } + $output->add( ';' ); + } + } + + public function toCSS(){ + $features = $this->features ? ' ' . $this->features->toCSS() : ''; + + if ($this->css) { + return "@import " . $this->path->toCSS() . $features . ";\n"; + } else { + return ""; + } + } + + /** + * @return string + */ + public function getPath(){ + if ($this->path instanceof Less_Tree_Quoted) { + $path = $this->path->value; + $path = ( isset($this->css) || preg_match('/(\.[a-z]*$)|([\?;].*)$/',$path)) ? $path : $path . '.less'; + } else if ($this->path instanceof Less_Tree_URL) { + $path = $this->path->value->value; + }else{ + return null; + } + + //remove query string and fragment + return preg_replace('/[\?#][^\?]*$/','',$path); + } + + public function compileForImport( $env ){ + return new Less_Tree_Import( $this->path->compile($env), $this->features, $this->options, $this->index, $this->currentFileInfo); + } + + public function compilePath($env) { + $path = $this->path->compile($env); + $rootpath = ''; + if( $this->currentFileInfo && $this->currentFileInfo['rootpath'] ){ + $rootpath = $this->currentFileInfo['rootpath']; + } + + + if( !($path instanceof Less_Tree_URL) ){ + if( $rootpath ){ + $pathValue = $path->value; + // Add the base path if the import is relative + if( $pathValue && Less_Environment::isPathRelative($pathValue) ){ + $path->value = $this->currentFileInfo['uri_root'].$pathValue; + } + } + $path->value = Less_Environment::normalizePath($path->value); + } + + + + return $path; + } + + public function compile( $env ){ + + $evald = $this->compileForImport($env); + + //get path & uri + $path_and_uri = null; + if( is_callable(Less_Parser::$options['import_callback']) ){ + $path_and_uri = call_user_func(Less_Parser::$options['import_callback'],$evald); + } + + if( !$path_and_uri ){ + $path_and_uri = $evald->PathAndUri(); + } + + if( $path_and_uri ){ + list($full_path, $uri) = $path_and_uri; + }else{ + $full_path = $uri = $evald->getPath(); + } + + + //import once + if( $evald->skip( $full_path, $env) ){ + return array(); + } + + if( $this->options['inline'] ){ + //todo needs to reference css file not import + //$contents = new Less_Tree_Anonymous($this->root, 0, array('filename'=>$this->importedFilename), true ); + + Less_Parser::AddParsedFile($full_path); + $contents = new Less_Tree_Anonymous( file_get_contents($full_path), 0, array(), true ); + + if( $this->features ){ + return new Less_Tree_Media( array($contents), $this->features->value ); + } + + return array( $contents ); + } + + // optional (need to be before "CSS" to support optional CSS imports. CSS should be checked only if empty($this->currentFileInfo)) + if( isset($this->options['optional']) && $this->options['optional'] && !file_exists($full_path) && (!$evald->css || !empty($this->currentFileInfo))) { + return array(); + } + + + // css ? + if( $evald->css ){ + $features = ( $evald->features ? $evald->features->compile($env) : null ); + return new Less_Tree_Import( $this->compilePath( $env), $features, $this->options, $this->index); + } + + + return $this->ParseImport( $full_path, $uri, $env ); + } + + + /** + * Using the import directories, get the full absolute path and uri of the import + * + * @param Less_Tree_Import $evald + */ + public function PathAndUri(){ + + $evald_path = $this->getPath(); + + if( $evald_path ){ + + $import_dirs = array(); + + if( Less_Environment::isPathRelative($evald_path) ){ + //if the path is relative, the file should be in the current directory + $import_dirs[ $this->currentFileInfo['currentDirectory'] ] = $this->currentFileInfo['uri_root']; + + }else{ + //otherwise, the file should be relative to the server root + $import_dirs[ $this->currentFileInfo['entryPath'] ] = $this->currentFileInfo['entryUri']; + + //if the user supplied entryPath isn't the actual root + $import_dirs[ $_SERVER['DOCUMENT_ROOT'] ] = ''; + + } + + // always look in user supplied import directories + $import_dirs = array_merge( $import_dirs, Less_Parser::$options['import_dirs'] ); + + + foreach( $import_dirs as $rootpath => $rooturi){ + if( is_callable($rooturi) ){ + list($path, $uri) = call_user_func($rooturi, $evald_path); + if( is_string($path) ){ + $full_path = $path; + return array( $full_path, $uri ); + } + }elseif( !empty($rootpath) ){ + + + if( $rooturi ){ + if( strpos($evald_path,$rooturi) === 0 ){ + $evald_path = substr( $evald_path, strlen($rooturi) ); + } + } + + $path = rtrim($rootpath,'/\\').'/'.ltrim($evald_path,'/\\'); + + if( file_exists($path) ){ + $full_path = Less_Environment::normalizePath($path); + $uri = Less_Environment::normalizePath(dirname($rooturi.$evald_path)); + return array( $full_path, $uri ); + } elseif( file_exists($path.'.less') ){ + $full_path = Less_Environment::normalizePath($path.'.less'); + $uri = Less_Environment::normalizePath(dirname($rooturi.$evald_path.'.less')); + return array( $full_path, $uri ); + } + } + } + } + } + + + /** + * Parse the import url and return the rules + * + * @return Less_Tree_Media|array + */ + public function ParseImport( $full_path, $uri, $env ){ + + $import_env = clone $env; + if( (isset($this->options['reference']) && $this->options['reference']) || isset($this->currentFileInfo['reference']) ){ + $import_env->currentFileInfo['reference'] = true; + } + + if( (isset($this->options['multiple']) && $this->options['multiple']) ){ + $import_env->importMultiple = true; + } + + $parser = new Less_Parser($import_env); + $root = $parser->parseFile($full_path, $uri, true); + + + $ruleset = new Less_Tree_Ruleset(array(), $root->rules ); + $ruleset->evalImports($import_env); + + return $this->features ? new Less_Tree_Media($ruleset->rules, $this->features->value) : $ruleset->rules; + } + + + /** + * Should the import be skipped? + * + * @return boolean|null + */ + private function Skip($path, $env){ + + $path = Less_Parser::winPath(realpath($path)); + + if( $path && Less_Parser::FileParsed($path) ){ + + if( isset($this->currentFileInfo['reference']) ){ + return true; + } + + return !isset($this->options['multiple']) && !$env->importMultiple; + } + + } +} + + +/** + * Javascript + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Javascript extends Less_Tree{ + + public $type = 'Javascript'; + public $escaped; + public $expression; + public $index; + + /** + * @param boolean $index + * @param boolean $escaped + */ + public function __construct($string, $index, $escaped){ + $this->escaped = $escaped; + $this->expression = $string; + $this->index = $index; + } + + public function compile(){ + return new Less_Tree_Anonymous('/* Sorry, can not do JavaScript evaluation in PHP... :( */'); + } + +} + + +/** + * Keyword + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Keyword extends Less_Tree{ + + public $value; + public $type = 'Keyword'; + + /** + * @param string $value + */ + public function __construct($value){ + $this->value = $value; + } + + public function compile(){ + return $this; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + if( $this->value === '%') { + throw new Less_Exception_Compiler("Invalid % without number"); + } + + $output->add( $this->value ); + } + + public function compare($other) { + if ($other instanceof Less_Tree_Keyword) { + return $other->value === $this->value ? 0 : 1; + } else { + return -1; + } + } +} + + +/** + * Media + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Media extends Less_Tree{ + + public $features; + public $rules; + public $index; + public $currentFileInfo; + public $isReferenced; + public $type = 'Media'; + + public function __construct($value = array(), $features = array(), $index = null, $currentFileInfo = null ){ + + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + + $selectors = $this->emptySelectors(); + + $this->features = new Less_Tree_Value($features); + + $this->rules = array(new Less_Tree_Ruleset($selectors, $value)); + $this->rules[0]->allowImports = true; + } + + public function accept( $visitor ){ + $this->features = $visitor->visitObj($this->features); + $this->rules = $visitor->visitArray($this->rules); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + $output->add( '@media ', $this->currentFileInfo, $this->index ); + $this->features->genCSS( $output ); + Less_Tree::outputRuleset( $output, $this->rules); + + } + + public function compile($env) { + + $media = new Less_Tree_Media(array(), array(), $this->index, $this->currentFileInfo ); + + $strictMathBypass = false; + if( Less_Parser::$options['strictMath'] === false) { + $strictMathBypass = true; + Less_Parser::$options['strictMath'] = true; + } + + $media->features = $this->features->compile($env); + + if( $strictMathBypass ){ + Less_Parser::$options['strictMath'] = false; + } + + $env->mediaPath[] = $media; + $env->mediaBlocks[] = $media; + + array_unshift($env->frames, $this->rules[0]); + $media->rules = array($this->rules[0]->compile($env)); + array_shift($env->frames); + + array_pop($env->mediaPath); + + return !$env->mediaPath ? $media->compileTop($env) : $media->compileNested($env); + } + + public function variable($name) { + return $this->rules[0]->variable($name); + } + + public function find($selector) { + return $this->rules[0]->find($selector, $this); + } + + public function emptySelectors(){ + $el = new Less_Tree_Element('','&', $this->index, $this->currentFileInfo ); + $sels = array( new Less_Tree_Selector(array($el), array(), null, $this->index, $this->currentFileInfo) ); + $sels[0]->mediaEmpty = true; + return $sels; + } + + public function markReferenced(){ + $this->rules[0]->markReferenced(); + $this->isReferenced = true; + Less_Tree::ReferencedArray($this->rules[0]->rules); + } + + // evaltop + public function compileTop($env) { + $result = $this; + + if (count($env->mediaBlocks) > 1) { + $selectors = $this->emptySelectors(); + $result = new Less_Tree_Ruleset($selectors, $env->mediaBlocks); + $result->multiMedia = true; + } + + $env->mediaBlocks = array(); + $env->mediaPath = array(); + + return $result; + } + + public function compileNested($env) { + $path = array_merge($env->mediaPath, array($this)); + + // Extract the media-query conditions separated with `,` (OR). + foreach ($path as $key => $p) { + $value = $p->features instanceof Less_Tree_Value ? $p->features->value : $p->features; + $path[$key] = is_array($value) ? $value : array($value); + } + + // Trace all permutations to generate the resulting media-query. + // + // (a, b and c) with nested (d, e) -> + // a and d + // a and e + // b and c and d + // b and c and e + + $permuted = $this->permute($path); + $expressions = array(); + foreach($permuted as $path){ + + for( $i=0, $len=count($path); $i < $len; $i++){ + $path[$i] = Less_Parser::is_method($path[$i], 'toCSS') ? $path[$i] : new Less_Tree_Anonymous($path[$i]); + } + + for( $i = count($path) - 1; $i > 0; $i-- ){ + array_splice($path, $i, 0, array(new Less_Tree_Anonymous('and'))); + } + + $expressions[] = new Less_Tree_Expression($path); + } + $this->features = new Less_Tree_Value($expressions); + + + + // Fake a tree-node that doesn't output anything. + return new Less_Tree_Ruleset(array(), array()); + } + + public function permute($arr) { + if (!$arr) + return array(); + + if (count($arr) == 1) + return $arr[0]; + + $result = array(); + $rest = $this->permute(array_slice($arr, 1)); + foreach ($rest as $r) { + foreach ($arr[0] as $a) { + $result[] = array_merge( + is_array($a) ? $a : array($a), + is_array($r) ? $r : array($r) + ); + } + } + + return $result; + } + + public function bubbleSelectors($selectors) { + + if( !$selectors) return; + + $this->rules = array(new Less_Tree_Ruleset( $selectors, array($this->rules[0]))); + } + +} + + +/** + * A simple css name-value pair + * ex: width:100px; + * + * In bootstrap, there are about 600-1,000 simple name-value pairs (depending on how forgiving the match is) -vs- 6,020 dynamic rules (Less_Tree_Rule) + * Using the name-value object can speed up bootstrap compilation slightly, but it breaks color keyword interpretation: color:red -> color:#FF0000; + * + * @package Less + * @subpackage tree + */ +class Less_Tree_NameValue extends Less_Tree{ + + public $name; + public $value; + public $index; + public $currentFileInfo; + public $type = 'NameValue'; + public $important = ''; + + public function __construct($name, $value = null, $index = null, $currentFileInfo = null ){ + $this->name = $name; + $this->value = $value; + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + } + + public function genCSS( $output ){ + + $output->add( + $this->name + . Less_Environment::$_outputMap[': '] + . $this->value + . $this->important + . (((Less_Environment::$lastRule && Less_Parser::$options['compress'])) ? "" : ";") + , $this->currentFileInfo, $this->index); + } + + public function compile ($env){ + return $this; + } + + public function makeImportant(){ + $new = new Less_Tree_NameValue($this->name, $this->value, $this->index, $this->currentFileInfo); + $new->important = ' !important'; + return $new; + } + + +} + + +/** + * Negative + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Negative extends Less_Tree{ + + public $value; + public $type = 'Negative'; + + public function __construct($node){ + $this->value = $node; + } + + //function accept($visitor) { + // $this->value = $visitor->visit($this->value); + //} + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( '-' ); + $this->value->genCSS( $output ); + } + + public function compile($env) { + if( Less_Environment::isMathOn() ){ + $ret = new Less_Tree_Operation('*', array( new Less_Tree_Dimension(-1), $this->value ) ); + return $ret->compile($env); + } + return new Less_Tree_Negative( $this->value->compile($env) ); + } +} + +/** + * Operation + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Operation extends Less_Tree{ + + public $op; + public $operands; + public $isSpaced; + public $type = 'Operation'; + + /** + * @param string $op + */ + public function __construct($op, $operands, $isSpaced = false){ + $this->op = trim($op); + $this->operands = $operands; + $this->isSpaced = $isSpaced; + } + + public function accept($visitor) { + $this->operands = $visitor->visitArray($this->operands); + } + + public function compile($env){ + $a = $this->operands[0]->compile($env); + $b = $this->operands[1]->compile($env); + + + if( Less_Environment::isMathOn() ){ + + if( $a instanceof Less_Tree_Dimension && $b instanceof Less_Tree_Color ){ + $a = $a->toColor(); + + }elseif( $b instanceof Less_Tree_Dimension && $a instanceof Less_Tree_Color ){ + $b = $b->toColor(); + + } + + if( !method_exists($a,'operate') ){ + throw new Less_Exception_Compiler("Operation on an invalid type"); + } + + return $a->operate( $this->op, $b); + } + + return new Less_Tree_Operation($this->op, array($a, $b), $this->isSpaced ); + } + + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $this->operands[0]->genCSS( $output ); + if( $this->isSpaced ){ + $output->add( " " ); + } + $output->add( $this->op ); + if( $this->isSpaced ){ + $output->add( ' ' ); + } + $this->operands[1]->genCSS( $output ); + } + +} + + +/** + * Paren + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Paren extends Less_Tree{ + + public $value; + public $type = 'Paren'; + + public function __construct($value) { + $this->value = $value; + } + + public function accept($visitor){ + $this->value = $visitor->visitObj($this->value); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + $output->add( '(' ); + $this->value->genCSS( $output ); + $output->add( ')' ); + } + + public function compile($env) { + return new Less_Tree_Paren($this->value->compile($env)); + } + +} + + +/** + * Quoted + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Quoted extends Less_Tree{ + public $escaped; + public $value; + public $quote; + public $index; + public $currentFileInfo; + public $type = 'Quoted'; + + /** + * @param string $str + */ + public function __construct($str, $content = '', $escaped = false, $index = false, $currentFileInfo = null ){ + $this->escaped = $escaped; + $this->value = $content; + if( $str ){ + $this->quote = $str[0]; + } + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + if( !$this->escaped ){ + $output->add( $this->quote, $this->currentFileInfo, $this->index ); + } + $output->add( $this->value ); + if( !$this->escaped ){ + $output->add( $this->quote ); + } + } + + public function compile($env){ + + $value = $this->value; + if( preg_match_all('/`([^`]+)`/', $this->value, $matches) ){ + foreach($matches as $i => $match){ + $js = new Less_Tree_JavaScript($matches[1], $this->index, true); + $js = $js->compile()->value; + $value = str_replace($matches[0][$i], $js, $value); + } + } + + if( preg_match_all('/@\{([\w-]+)\}/',$value,$matches) ){ + foreach($matches[1] as $i => $match){ + $v = new Less_Tree_Variable('@' . $match, $this->index, $this->currentFileInfo ); + $v = $v->compile($env); + $v = ($v instanceof Less_Tree_Quoted) ? $v->value : $v->toCSS(); + $value = str_replace($matches[0][$i], $v, $value); + } + } + + return new Less_Tree_Quoted($this->quote . $value . $this->quote, $value, $this->escaped, $this->index, $this->currentFileInfo); + } + + public function compare($x) { + + if( !Less_Parser::is_method($x, 'toCSS') ){ + return -1; + } + + $left = $this->toCSS(); + $right = $x->toCSS(); + + if ($left === $right) { + return 0; + } + + return $left < $right ? -1 : 1; + } +} + + +/** + * Rule + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Rule extends Less_Tree{ + + public $name; + public $value; + public $important; + public $merge; + public $index; + public $inline; + public $variable; + public $currentFileInfo; + public $type = 'Rule'; + + /** + * @param string $important + */ + public function __construct($name, $value = null, $important = null, $merge = null, $index = null, $currentFileInfo = null, $inline = false){ + $this->name = $name; + $this->value = ($value instanceof Less_Tree_Value || $value instanceof Less_Tree_Ruleset) ? $value : new Less_Tree_Value(array($value)); + $this->important = $important ? ' ' . trim($important) : ''; + $this->merge = $merge; + $this->index = $index; + $this->currentFileInfo = $currentFileInfo; + $this->inline = $inline; + $this->variable = ( is_string($name) && $name[0] === '@'); + } + + public function accept($visitor) { + $this->value = $visitor->visitObj( $this->value ); + } + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + $output->add( $this->name . Less_Environment::$_outputMap[': '], $this->currentFileInfo, $this->index); + try{ + $this->value->genCSS( $output); + + }catch( Less_Exception_Parser $e ){ + $e->index = $this->index; + $e->currentFile = $this->currentFileInfo; + throw $e; + } + $output->add( $this->important . (($this->inline || (Less_Environment::$lastRule && Less_Parser::$options['compress'])) ? "" : ";"), $this->currentFileInfo, $this->index); + } + + public function compile ($env){ + + $name = $this->name; + if( is_array($name) ){ + // expand 'primitive' name directly to get + // things faster (~10% for benchmark.less): + if( count($name) === 1 && $name[0] instanceof Less_Tree_Keyword ){ + $name = $name[0]->value; + }else{ + $name = $this->CompileName($env,$name); + } + } + + $strictMathBypass = Less_Parser::$options['strictMath']; + if( $name === "font" && !Less_Parser::$options['strictMath'] ){ + Less_Parser::$options['strictMath'] = true; + } + + try { + $evaldValue = $this->value->compile($env); + + if( !$this->variable && $evaldValue->type === "DetachedRuleset") { + throw new Less_Exception_Compiler("Rulesets cannot be evaluated on a property.", null, $this->index, $this->currentFileInfo); + } + + if( Less_Environment::$mixin_stack ){ + $return = new Less_Tree_Rule($name, $evaldValue, $this->important, $this->merge, $this->index, $this->currentFileInfo, $this->inline); + }else{ + $this->name = $name; + $this->value = $evaldValue; + $return = $this; + } + + }catch( Less_Exception_Parser $e ){ + if( !is_numeric($e->index) ){ + $e->index = $this->index; + $e->currentFile = $this->currentFileInfo; + } + throw $e; + } + + Less_Parser::$options['strictMath'] = $strictMathBypass; + + return $return; + } + + + public function CompileName( $env, $name ){ + $output = new Less_Output(); + foreach($name as $n){ + $n->compile($env)->genCSS($output); + } + return $output->toString(); + } + + public function makeImportant(){ + return new Less_Tree_Rule($this->name, $this->value, '!important', $this->merge, $this->index, $this->currentFileInfo, $this->inline); + } + +} + + +/** + * Ruleset + * + * @package Less + * @subpackage tree + */ +class Less_Tree_Ruleset extends Less_Tree{ + + protected $lookups; + public $_variables; + public $_rulesets; + + public $strictImports; + + public $selectors; + public $rules; + public $root; + public $allowImports; + public $paths; + public $firstRoot; + public $type = 'Ruleset'; + public $multiMedia; + public $allExtends; + + public $ruleset_id; + public $originalRuleset; + + public $first_oelements; + + public function SetRulesetIndex(){ + $this->ruleset_id = Less_Parser::$next_id++; + $this->originalRuleset = $this->ruleset_id; + + if( $this->selectors ){ + foreach($this->selectors as $sel){ + if( $sel->_oelements ){ + $this->first_oelements[$sel->_oelements[0]] = true; + } + } + } + } + + public function __construct($selectors, $rules, $strictImports = null){ + $this->selectors = $selectors; + $this->rules = $rules; + $this->lookups = array(); + $this->strictImports = $strictImports; + $this->SetRulesetIndex(); + } + + public function accept( $visitor ){ + if( $this->paths ){ + $paths_len = count($this->paths); + for($i = 0,$paths_len; $i < $paths_len; $i++ ){ + $this->paths[$i] = $visitor->visitArray($this->paths[$i]); + } + }elseif( $this->selectors ){ + $this->selectors = $visitor->visitArray($this->selectors); + } + + if( $this->rules ){ + $this->rules = $visitor->visitArray($this->rules); + } + } + + public function compile($env){ + + $ruleset = $this->PrepareRuleset($env); + + + // Store the frames around mixin definitions, + // so they can be evaluated like closures when the time comes. + $rsRuleCnt = count($ruleset->rules); + for( $i = 0; $i < $rsRuleCnt; $i++ ){ + if( $ruleset->rules[$i] instanceof Less_Tree_Mixin_Definition || $ruleset->rules[$i] instanceof Less_Tree_DetachedRuleset ){ + $ruleset->rules[$i] = $ruleset->rules[$i]->compile($env); + } + } + + $mediaBlockCount = 0; + if( $env instanceof Less_Environment ){ + $mediaBlockCount = count($env->mediaBlocks); + } + + // Evaluate mixin calls. + $this->EvalMixinCalls( $ruleset, $env, $rsRuleCnt ); + + + // Evaluate everything else + for( $i=0; $i<$rsRuleCnt; $i++ ){ + if(! ($ruleset->rules[$i] instanceof Less_Tree_Mixin_Definition || $ruleset->rules[$i] instanceof Less_Tree_DetachedRuleset) ){ + $ruleset->rules[$i] = $ruleset->rules[$i]->compile($env); + } + } + + // Evaluate everything else + for( $i=0; $i<$rsRuleCnt; $i++ ){ + $rule = $ruleset->rules[$i]; + + // for rulesets, check if it is a css guard and can be removed + if( $rule instanceof Less_Tree_Ruleset && $rule->selectors && count($rule->selectors) === 1 ){ + + // check if it can be folded in (e.g. & where) + if( $rule->selectors[0]->isJustParentSelector() ){ + array_splice($ruleset->rules,$i--,1); + $rsRuleCnt--; + + for($j = 0; $j < count($rule->rules); $j++ ){ + $subRule = $rule->rules[$j]; + if( !($subRule instanceof Less_Tree_Rule) || !$subRule->variable ){ + array_splice($ruleset->rules, ++$i, 0, array($subRule)); + $rsRuleCnt++; + } + } + + } + } + } + + + // Pop the stack + $env->shiftFrame(); + + if ($mediaBlockCount) { + $len = count($env->mediaBlocks); + for($i = $mediaBlockCount; $i < $len; $i++ ){ + $env->mediaBlocks[$i]->bubbleSelectors($ruleset->selectors); + } + } + + return $ruleset; + } + + /** + * Compile Less_Tree_Mixin_Call objects + * + * @param Less_Tree_Ruleset $ruleset + * @param integer $rsRuleCnt + */ + private function EvalMixinCalls( $ruleset, $env, &$rsRuleCnt ){ + for($i=0; $i < $rsRuleCnt; $i++){ + $rule = $ruleset->rules[$i]; + + if( $rule instanceof Less_Tree_Mixin_Call ){ + $rule = $rule->compile($env); + + $temp = array(); + foreach($rule as $r){ + if( ($r instanceof Less_Tree_Rule) && $r->variable ){ + // do not pollute the scope if the variable is + // already there. consider returning false here + // but we need a way to "return" variable from mixins + if( !$ruleset->variable($r->name) ){ + $temp[] = $r; + } + }else{ + $temp[] = $r; + } + } + $temp_count = count($temp)-1; + array_splice($ruleset->rules, $i, 1, $temp); + $rsRuleCnt += $temp_count; + $i += $temp_count; + $ruleset->resetCache(); + + }elseif( $rule instanceof Less_Tree_RulesetCall ){ + + $rule = $rule->compile($env); + $rules = array(); + foreach($rule->rules as $r){ + if( ($r instanceof Less_Tree_Rule) && $r->variable ){ + continue; + } + $rules[] = $r; + } + + array_splice($ruleset->rules, $i, 1, $rules); + $temp_count = count($rules); + $rsRuleCnt += $temp_count - 1; + $i += $temp_count-1; + $ruleset->resetCache(); + } + + } + } + + + /** + * Compile the selectors and create a new ruleset object for the compile() method + * + */ + private function PrepareRuleset($env){ + + $hasOnePassingSelector = false; + $selectors = array(); + if( $this->selectors ){ + Less_Tree_DefaultFunc::error("it is currently only allowed in parametric mixin guards,"); + + foreach($this->selectors as $s){ + $selector = $s->compile($env); + $selectors[] = $selector; + if( $selector->evaldCondition ){ + $hasOnePassingSelector = true; + } + } + + Less_Tree_DefaultFunc::reset(); + } else { + $hasOnePassingSelector = true; + } + + if( $this->rules && $hasOnePassingSelector ){ + $rules = $this->rules; + }else{ + $rules = array(); + } + + $ruleset = new Less_Tree_Ruleset($selectors, $rules, $this->strictImports); + + $ruleset->originalRuleset = $this->ruleset_id; + + $ruleset->root = $this->root; + $ruleset->firstRoot = $this->firstRoot; + $ruleset->allowImports = $this->allowImports; + + + // push the current ruleset to the frames stack + $env->unshiftFrame($ruleset); + + + // Evaluate imports + if( $ruleset->root || $ruleset->allowImports || !$ruleset->strictImports ){ + $ruleset->evalImports($env); + } + + return $ruleset; + } + + function evalImports($env) { + + $rules_len = count($this->rules); + for($i=0; $i < $rules_len; $i++){ + $rule = $this->rules[$i]; + + if( $rule instanceof Less_Tree_Import ){ + $rules = $rule->compile($env); + if( is_array($rules) ){ + array_splice($this->rules, $i, 1, $rules); + $temp_count = count($rules)-1; + $i += $temp_count; + $rules_len += $temp_count; + }else{ + array_splice($this->rules, $i, 1, array($rules)); + } + + $this->resetCache(); + } + } + } + + function makeImportant(){ + + $important_rules = array(); + foreach($this->rules as $rule){ + if( $rule instanceof Less_Tree_Rule || $rule instanceof Less_Tree_Ruleset || $rule instanceof Less_Tree_NameValue ){ + $important_rules[] = $rule->makeImportant(); + }else{ + $important_rules[] = $rule; + } + } + + return new Less_Tree_Ruleset($this->selectors, $important_rules, $this->strictImports ); + } + + public function matchArgs($args){ + return !$args; + } + + // lets you call a css selector with a guard + public function matchCondition( $args, $env ){ + $lastSelector = end($this->selectors); + + if( !$lastSelector->evaldCondition ){ + return false; + } + if( $lastSelector->condition && !$lastSelector->condition->compile( $env->copyEvalEnv( $env->frames ) ) ){ + return false; + } + return true; + } + + function resetCache(){ + $this->_rulesets = null; + $this->_variables = null; + $this->lookups = array(); + } + + public function variables(){ + $this->_variables = array(); + foreach( $this->rules as $r){ + if ($r instanceof Less_Tree_Rule && $r->variable === true) { + $this->_variables[$r->name] = $r; + } + } + } + + public function variable($name){ + + if( is_null($this->_variables) ){ + $this->variables(); + } + return isset($this->_variables[$name]) ? $this->_variables[$name] : null; + } + + public function find( $selector, $self = null ){ + + $key = implode(' ',$selector->_oelements); + + if( !isset($this->lookups[$key]) ){ + + if( !$self ){ + $self = $this->ruleset_id; + } + + $this->lookups[$key] = array(); + + $first_oelement = $selector->_oelements[0]; + + foreach($this->rules as $rule){ + if( $rule instanceof Less_Tree_Ruleset && $rule->ruleset_id != $self ){ + + if( isset($rule->first_oelements[$first_oelement]) ){ + + foreach( $rule->selectors as $ruleSelector ){ + $match = $selector->match($ruleSelector); + if( $match ){ + if( $selector->elements_len > $match ){ + $this->lookups[$key] = array_merge($this->lookups[$key], $rule->find( new Less_Tree_Selector(array_slice($selector->elements, $match)), $self)); + } else { + $this->lookups[$key][] = $rule; + } + break; + } + } + } + } + } + } + + return $this->lookups[$key]; + } + + + /** + * @see Less_Tree::genCSS + */ + public function genCSS( $output ){ + + if( !$this->root ){ + Less_Environment::$tabLevel++; + } + + $tabRuleStr = $tabSetStr = ''; + if( !Less_Parser::$options['compress'] ){ + if( Less_Environment::$tabLevel ){ + $tabRuleStr = "\n".str_repeat( Less_Parser::$options['indentation'] , Less_Environment::$tabLevel ); + $tabSetStr = "\n".str_repeat( Less_Parser::$options['indentation'] , Less_Environment::$tabLevel-1 ); + }else{ + $tabSetStr = $tabRuleStr = "\n"; + } + } + + + $ruleNodes = array(); + $rulesetNodes = array(); + foreach($this->rules as $rule){ + + $class = get_class($rule); + if( ($class === 'Less_Tree_Media') || ($class === 'Less_Tree_Directive') || ($this->root && $class === 'Less_Tree_Comment') || ($class === 'Less_Tree_Ruleset' && $rule->rules) ){ + $rulesetNodes[] = $rule; + }else{ + $ruleNodes[] = $rule; + } + } + + // If this is the root node, we don't render + // a selector, or {}. + if( !$this->root ){ + + /* + debugInfo = tree.debugInfo(env, this, tabSetStr); + + if (debugInfo) { + output.add(debugInfo); + output.add(tabSetStr); + } + */ + + $paths_len = count($this->paths); + for( $i = 0; $i < $paths_len; $i++ ){ + $path = $this->paths[$i]; + $firstSelector = true; + + foreach($path as $p){ + $p->genCSS( $output, $firstSelector ); + $firstSelector = false; + } + + if( $i + 1 < $paths_len ){ + $output->add( ',' . $tabSetStr ); + } + } + + $output->add( (Less_Parser::$options['compress'] ? '{' : " {") . $tabRuleStr ); + } + + // Compile rules and rulesets + $ruleNodes_len = count($ruleNodes); + $rulesetNodes_len = count($rulesetNodes); + for( $i = 0; $i < $ruleNodes_len; $i++ ){ + $rule = $ruleNodes[$i]; + + // @page{ directive ends up with root elements inside it, a mix of rules and rulesets + // In this instance we do not know whether it is the last property + if( $i + 1 === $ruleNodes_len && (!$this->root || $rulesetNodes_len === 0 || $this->firstRoot ) ){ + Less_Environment::$lastRule = true; + } + + $rule->genCSS( $output ); + + if( !Less_Environment::$lastRule ){ + $output->add( $tabRuleStr ); + }else{ + Less_Environment::$lastRule = false; + } + } + + if( !$this->root ){ + $output->add( $tabSetStr . '}' ); + Less_Environment::$tabLevel--; + } + + $firstRuleset = true; + $space = ($this->root ? $tabRuleStr : $tabSetStr); + for( $i = 0; $i < $rulesetNodes_len; $i++ ){ + + if( $ruleNodes_len && $firstRuleset ){ + $output->add( $space ); + }elseif( !$firstRuleset ){ + $output->add( $space ); + } + $firstRuleset = false; + $rulesetNodes[$i]->genCSS( $output); + } + + if( !Less_Parser::$options['compress'] && $this->firstRoot ){ + $output->add( "\n" ); + } + + } + + + function markReferenced(){ + if( !$this->selectors ){ + return; + } + foreach($this->selectors as $selector){ + $selector->markReferenced(); + } + } + + public function joinSelectors( $context, $selectors ){ + $paths = array(); + if( is_array($selectors) ){ + foreach($selectors as $selector) { + $this->joinSelector( $paths, $context, $selector); + } + } + return $paths; + } + + public function joinSelector( &$paths, $context, $selector){ + + $hasParentSelector = false; + + foreach($selector->elements as $el) { + if( $el->value === '&') { + $hasParentSelector = true; + } + } + + if( !$hasParentSelector ){ + if( $context ){ + foreach($context as $context_el){ + $paths[] = array_merge($context_el, array($selector) ); + } + }else { + $paths[] = array($selector); + } + return; + } + + + // The paths are [[Selector]] + // The first list is a list of comma seperated selectors + // The inner list is a list of inheritance seperated selectors + // e.g. <