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;
}
/**
* @param Less_Functions $ctx
*/
public function compile($ctx)
{
$val = $this->value->compile($ctx);
if (!$this->isEvald) {
// Add the base path if the URL is relative
if (Less_Parser::$options['relativeUrls'] && $this->currentFileInfo && is_string($val->value) && Less_Environment::isPathRelative($val->value)) {
$rootpath = $this->currentFileInfo['uri_root'];
if (!$val->quote) {
$rootpath = preg_replace('/[\\(\\)\'"\\s]/', '\\$1', $rootpath);
}
$val->value = $rootpath . $val->value;
}
$val->value = Less_Environment::normalizePath($val->value);
}
// Add cache buster if enabled
if (Less_Parser::$options['urlArgs']) {
if (!preg_match('/^\\s*data:/', $val->value)) {
$delimiter = strpos($val->value, '?') === false ? '?' : '&';
$urlArgs = $delimiter . Less_Parser::$options['urlArgs'];
$hash_pos = strpos($val->value, '#');
if ($hash_pos !== false) {
$val->value = substr_replace($val->value, $urlArgs, $hash_pos, 0);
} else {
$val->value .= $urlArgs;
}
}
}
return new Less_Tree_URL($val, $this->currentFileInfo, true);
}
public function operate($env, $op, $other)
{
$value = Less_Environment::operate($env, $op, $this->value, $other->value);
$unit = clone $this->unit;
if ($op === '+' || $op === '-') {
if (!count($unit->numerator) && !count($unit->denominator)) {
$unit->numerator = $other->unit->numerator;
$unit->denominator = $other->unit->denominator;
} elseif (!count($other->unit->numerator) && !count($other->unit->denominator)) {
// do nothing
} else {
$other = $other->convertTo($this->unit->usedUnits());
if ($env->strictUnits && $other->unit->toString() !== $unit->toCSS()) {
throw new Less_CompilerException("Incompatible units. Change the units or use the unit function. Bad units: '" . $unit->toString() . "' and " . $other->unit->toString() + "'.");
}
$value = Less_Environment::operate($env, $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 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));
}
public function operate($env, $op, $other)
{
$result = array();
if (!$other instanceof Less_Tree_Color) {
$other = $other->toColor();
}
for ($c = 0; $c < 3; $c++) {
$result[$c] = Less_Environment::operate($env, $op, $this->rgb[$c], $other->rgb[$c]);
}
return new Less_Tree_Color($result, $this->alpha + $other->alpha);
}
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 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);
}
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));
}
/**
* @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");
}
}
/**
* @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;
}
/**
* 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)) {
$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);
}
}
}
}
}
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;
}
function compile($env)
{
$evald = $this->compileForImport($env);
$uri = $full_path = false;
//get path & uri
$evald_path = $evald->getPath();
if ($evald_path && $env->isPathRelative($evald_path)) {
foreach (Less_Parser::$import_dirs as $rootpath => $rooturi) {
$temp = $rootpath . $evald_path;
if (file_exists($temp)) {
$full_path = Less_Environment::NormPath($temp);
$uri = Less_Environment::NormPath(dirname($rooturi . $evald_path));
break;
}
}
}
if (!$full_path) {
$uri = $evald_path;
$full_path = $evald_path;
}
//import once
$realpath = realpath($full_path);
if (!isset($evald->options['multiple']) && $realpath && Less_Parser::FileParsed($realpath)) {
$evald->skip = true;
}
$features = $evald->features ? $evald->features->compile($env) : null;
if ($evald->skip) {
return array();
}
if ($evald->css) {
$temp = $this->compilePath($env);
return new Less_Tree_Import($this->compilePath($env), $features, $this->options, $this->index);
}
$parser = new Less_Parser($env);
$evald->root = $parser->parseFile($full_path, $uri, true);
$ruleset = new Less_Tree_Ruleset(array(), $evald->root->rules);
$ruleset->evalImports($env);
return $this->features ? new Less_Tree_Media($ruleset->rules, $this->features->value) : $ruleset->rules;
}
/**
* @param Less_Functions $ctx
*/
public function compile($ctx)
{
$val = $this->value->compile($ctx);
if (!$this->isEvald) {
// Add the base path if the URL is relative
if (Less_Parser::$options['relativeUrls'] && $this->currentFileInfo && is_string($val->value) && Less_Environment::isPathRelative($val->value)) {
$rootpath = $this->currentFileInfo['uri_root'];
if (!$val->quote) {
$rootpath = preg_replace('/[\\(\\)\'"\\s]/', '\\$1', $rootpath);
}
$val->value = $rootpath . $val->value;
}
$val->value = Less_Environment::normalizePath($val->value);
}
return new Less_Tree_URL($val, $this->currentFileInfo, true);
}
public function compile($env, $args = NULL, $important = NULL)
{
$_arguments = array();
$mixinFrames = array_merge($this->frames, $env->frames);
$mixinEnv = new Less_Environment();
$mixinEnv->addFrames($mixinFrames);
$frame = $this->compileParams($env, $mixinEnv, $args, $_arguments);
$ex = new Less_Tree_Expression($_arguments);
array_unshift($frame->rules, new Less_Tree_Rule('@arguments', $ex->compile($env)));
$rules = $important ? Less_Tree_Ruleset::makeImportant($this->selectors, $this->rules)->rules : array_slice($this->rules, 0);
$ruleset = new Less_Tree_Ruleset(null, $rules);
// duplicate the environment, adding new frames.
$ruleSetEnv = new Less_Environment();
$ruleSetEnv->addFrame($this);
$ruleSetEnv->addFrame($frame);
$ruleSetEnv->addFrames($mixinFrames);
$ruleSetEnv->compress = $env->compress;
$ruleset = $ruleset->compile($ruleSetEnv);
$ruleset->originalRuleset = $this;
return $ruleset;
}
public function SetFileInfo( $filename, $uri_root = ''){
$this->path = pathinfo($filename, PATHINFO_DIRNAME);
$this->filename = Less_Environment::NormPath($filename);
$dirname = preg_replace('/[^\/\\\\]*$/','',$this->filename);
$currentFileInfo = array();
$currentFileInfo['currentDirectory'] = $dirname;
$currentFileInfo['filename'] = $filename;
$currentFileInfo['rootpath'] = $dirname;
$currentFileInfo['entryPath'] = $dirname;
if( empty($uri_root) ){
$currentFileInfo['uri_root'] = $uri_root;
}else{
$currentFileInfo['uri_root'] = rtrim($uri_root,'/').'/';
}
$this->env->currentFileInfo = $currentFileInfo;
self::$import_dirs = array_merge( array( $dirname => $currentFileInfo['uri_root'] ), self::$import_dirs );
}
