vendor/wikimedia/less.php/lib/Less/Parser.php line 2033

Open in your IDE?
  1. <?php
  3. require_once( dirname(__FILE__).'/Cache.php');
  5. /**
  6.  * Class for parsing and compiling less files into css
  7.  *
  8.  * @package Less
  9.  * @subpackage parser
  10.  *
  11.  */
  12. class Less_Parser{
  15.     /**
  16.      * Default parser options
  17.      */
  18.     public static $default_options = array(
  19.         'compress'                => false,            // option - whether to compress
  20.         'strictUnits'            => false,            // whether units need to evaluate correctly
  21.         'strictMath'            => false,            // whether math has to be within parenthesis
  22.         'relativeUrls'            => true,            // option - whether to adjust URL's to be relative
  23.         'urlArgs'                => '',                // whether to add args into url tokens
  24.         'numPrecision'            => 8,
  26.         'import_dirs'            => array(),
  27.         'import_callback'        => null,
  28.         'cache_dir'                => null,
  29.         'cache_method'            => 'php',             // false, 'serialize', 'php', 'var_export', 'callback';
  30.         'cache_callback_get'    => null,
  31.         'cache_callback_set'    => null,
  33.         'sourceMap'                => false,            // whether to output a source map
  34.         'sourceMapBasepath'        => null,
  35.         'sourceMapWriteTo'        => null,
  36.         'sourceMapURL'            => null,
  38.         'indentation'             => '  ',
  40.         'plugins'                => array(),
  42.     );
  44.     public static $options = array();
  47.     private $input;                    // Less input string
  48.     private $input_len;                // input string length
  49.     private $pos;                    // current index in `input`
  50.     private $saveStack = array();    // holds state for backtracking
  51.     private $furthest;
  52.     private $mb_internal_encoding = ''; // for remember exists value of mbstring.internal_encoding
  54.     /**
  55.      * @var Less_Environment
  56.      */
  57.     private $env;
  59.     protected $rules = array();
  61.     private static $imports = array();
  63.     public static $has_extends = false;
  65.     public static $next_id = 0;
  67.     /**
  68.      * Filename to contents of all parsed the files
  69.      *
  70.      * @var array
  71.      */
  72.     public static $contentsMap = array();
  75.     /**
  76.      * @param Less_Environment|array|null $env
  77.      */
  78.     public function __construct( $env = null ){
  80.         // Top parser on an import tree must be sure there is one "env"
  81.         // which will then be passed around by reference.
  82.         if( $env instanceof Less_Environment ){
  83.             $this->env = $env;
  84.         }else{
  85.             $this->SetOptions(Less_Parser::$default_options);
  86.             $this->Reset( $env );
  87.         }
  89.         // mbstring.func_overload > 1 bugfix
  90.         // The encoding value must be set for each source file,
  91.         // therefore, to conserve resources and improve the speed of this design is taken here
  92.         if (ini_get('mbstring.func_overload')) {
  93.             $this->mb_internal_encoding = ini_get('mbstring.internal_encoding');
  94.             @ini_set('mbstring.internal_encoding', 'ascii');
  95.         }
  97.     }
  100.     /**
  101.      * Reset the parser state completely
  102.      *
  103.      */
  104.     public function Reset( $options = null ){
  105.         $this->rules = array();
  106.         self::$imports = array();
  107.         self::$has_extends = false;
  108.         self::$imports = array();
  109.         self::$contentsMap = array();
  111.         $this->env = new Less_Environment($options);
  113.         //set new options
  114.         if( is_array($options) ){
  115.             $this->SetOptions(Less_Parser::$default_options);
  116.             $this->SetOptions($options);
  117.         }
  119.         $this->env->Init();
  120.     }
  122.     /**
  123.      * Set one or more compiler options
  124.      *  options: import_dirs, cache_dir, cache_method
  125.      *
  126.      */
  127.     public function SetOptions( $options ){
  128.         foreach($options as $option => $value){
  129.             $this->SetOption($option,$value);
  130.         }
  131.     }
  133.     /**
  134.      * Set one compiler option
  135.      *
  136.      */
  137.     public function SetOption($option,$value){
  139.         switch($option){
  141.             case 'import_dirs':
  142.                 $this->SetImportDirs($value);
  143.             return;
  145.             case 'cache_dir':
  146.                 if( is_string($value) ){
  147.                     Less_Cache::SetCacheDir($value);
  148.                     Less_Cache::CheckCacheDir();
  149.                 }
  150.             return;
  151.         }
  153.         Less_Parser::$options[$option] = $value;
  154.     }
  156.     /**
  157.      * Registers a new custom function
  158.      *
  159.      * @param  string   $name     function name
  160.      * @param  callable $callback callback
  161.      */
  162.     public function registerFunction($name, $callback) {
  163.         $this->env->functions[$name] = $callback;
  164.     }
  166.     /**
  167.      * Removed an already registered function
  168.      *
  169.      * @param  string $name function name
  170.      */
  171.     public function unregisterFunction($name) {
  172.         if( isset($this->env->functions[$name]) )
  173.             unset($this->env->functions[$name]);
  174.     }
  177.     /**
  178.      * Get the current css buffer
  179.      *
  180.      * @return string
  181.      */
  182.     public function getCss(){
  184.         $precision = ini_get('precision');
  185.         @ini_set('precision',16);
  186.         $locale = setlocale(LC_NUMERIC, 0);
  187.         setlocale(LC_NUMERIC, "C");
  189.         try {
  191.              $root = new Less_Tree_Ruleset(array(), $this->rules );
  192.             $root->root = true;
  193.             $root->firstRoot = true;
  196.             $this->PreVisitors($root);
  198.             self::$has_extends = false;
  199.             $evaldRoot = $root->compile($this->env);
  203.             $this->PostVisitors($evaldRoot);
  205.             if( Less_Parser::$options['sourceMap'] ){
  206.                 $generator = new Less_SourceMap_Generator($evaldRoot, Less_Parser::$contentsMap, Less_Parser::$options );
  207.                 // will also save file
  208.                 // FIXME: should happen somewhere else?
  209.                 $css = $generator->generateCSS();
  210.             }else{
  211.                 $css = $evaldRoot->toCSS();
  212.             }
  214.             if( Less_Parser::$options['compress'] ){
  215.                 $css = preg_replace('/(^(\s)+)|((\s)+$)/', '', $css);
  216.             }
  218.         } catch (Exception $exc) {
  219.             // Intentional fall-through so we can reset environment
  220.         }
  222.         //reset php settings
  223.         @ini_set('precision',$precision);
  224.         setlocale(LC_NUMERIC, $locale);
  226.         // If you previously defined $this->mb_internal_encoding
  227.         // is required to return the encoding as it was before
  228.         if ($this->mb_internal_encoding != '') {
  229.             @ini_set("mbstring.internal_encoding", $this->mb_internal_encoding);
  230.             $this->mb_internal_encoding = '';
  231.         }
  233.         // Rethrow exception after we handled resetting the environment
  234.         if (!empty($exc)) {
  235.             throw $exc;
  236.         }
  238.         return $css;
  239.     }
  241.     public function findValueOf($varName)
  242.     {
  243.         foreach($this->rules as $rule){
  244.             if(isset($rule->variable) && ($rule->variable == true) && (str_replace("@","",$rule->name) == $varName)){
  245.                 return $this->getVariableValue($rule);
  246.             }
  247.         }
  248.         return null;
  249.     }
  251.     /**
  252.      *
  253.      * this function gets the private rules variable and returns an array of the found variables
  254.      * it uses a helper method getVariableValue() that contains the logic ot fetch the value from the rule object
  255.      *
  256.      * @return array
  257.      */
  258.     public function getVariables()
  259.     {
  260.         $variables = array();
  262.         $not_variable_type = array(
  263.             'Comment',   // this include less comments ( // ) and css comments (/* */)
  264.             'Import',    // do not search variables in included files @import
  265.             'Ruleset',   // selectors (.someclass, #someid, â€¦)
  266.             'Operation', //
  267.         );
  269.         // @TODO run compilation if not runned yet
  270.         foreach ($this->rules as $key => $rule) {
  271.             if (in_array($rule->type, $not_variable_type)) {
  272.                 continue;
  273.             }
  275.             // Note: it seems rule->type is always Rule when variable = true
  276.             if ($rule->type == 'Rule' && $rule->variable) {
  277.                 $variables[$rule->name] = $this->getVariableValue($rule);
  278.             } else {
  279.                 if ($rule->type == 'Comment') {
  280.                     $variables[] = $this->getVariableValue($rule);
  281.                 }
  282.             }
  283.         }
  284.         return $variables;
  285.     }
  287.     public function findVarByName($var_name)
  288.     {
  289.         foreach($this->rules as $rule){
  290.             if(isset($rule->variable) && ($rule->variable == true)){
  291.                 if($rule->name == $var_name){
  292.                     return $this->getVariableValue($rule);
  293.                 }
  294.             }
  295.         }
  296.         return null;
  297.     }
  299.     /**
  300.      *
  301.      * This method gets the value of the less variable from the rules object.
  302.      * Since the objects vary here we add the logic for extracting the css/less value.
  303.      *
  304.      * @param $var
  305.      *
  306.      * @return bool|string
  307.      */
  308.     private function getVariableValue($var)
  309.     {
  310.         if (!is_a($var, 'Less_Tree')) {
  311.             throw new Exception('var is not a Less_Tree object');
  312.         }
  314.         switch ($var->type) {
  315.             case 'Color':
  316.                 return $this->rgb2html($var->rgb);
  317.             case 'Unit':
  318.                 return $var->value. $var->unit->numerator[0];
  319.             case 'Variable':
  320.                 return $this->findVarByName($var->name);
  321.             case 'Keyword':
  322.                 return $var->value;
  323.             case 'Rule':
  324.                 return $this->getVariableValue($var->value);
  325.             case 'Value':
  326.                 $value = '';
  327.                 foreach ($var->value as $sub_value) {
  328.                     $value .= $this->getVariableValue($sub_value).' ';
  329.                 }
  330.                 return $value;
  331.             case 'Quoted':
  332.                 return $var->quote.$var->value.$var->quote;
  333.             case 'Dimension':
  334.                 $value = $var->value;
  335.                 if ($var->unit && $var->unit->numerator) {
  336.                     $value .= $var->unit->numerator[0];
  337.                 }
  338.                 return $value;
  339.             case 'Expression':
  340.                 $value = "";
  341.                 foreach($var->value as $item) {
  342.                     $value .= $this->getVariableValue($item)." ";
  343.                 }
  344.                 return $value;
  345.             case 'Operation':
  346.                 throw new Exception('getVariables() require Less to be compiled. please use $parser->getCss() before calling getVariables()');
  347.             case 'Comment':
  348.             case 'Import':
  349.             case 'Ruleset':
  350.             default:
  351.                 throw new Exception("type missing in switch/case getVariableValue for ".$var->type);
  352.         }
  353.         return false;
  354.     }
  356.     private function rgb2html($r, $g=-1, $b=-1)
  357.     {
  358.         if (is_array($r) && sizeof($r) == 3)
  359.             list($r, $g, $b) = $r;
  361.         $r = intval($r); $g = intval($g);
  362.         $b = intval($b);
  364.         $r = dechex($r<0?0:($r>255?255:$r));
  365.         $g = dechex($g<0?0:($g>255?255:$g));
  366.         $b = dechex($b<0?0:($b>255?255:$b));
  368.         $color = (strlen($r) < 2?'0':'').$r;
  369.         $color .= (strlen($g) < 2?'0':'').$g;
  370.         $color .= (strlen($b) < 2?'0':'').$b;
  371.         return '#'.$color;
  372.     }
  374.     /**
  375.      * Run pre-compile visitors
  376.      *
  377.      */
  378.     private function PreVisitors($root){
  380.         if( Less_Parser::$options['plugins'] ){
  381.             foreach(Less_Parser::$options['plugins'] as $plugin){
  382.                 if( !empty($plugin->isPreEvalVisitor) ){
  383.                     $plugin->run($root);
  384.                 }
  385.             }
  386.         }
  387.     }
  390.     /**
  391.      * Run post-compile visitors
  392.      *
  393.      */
  394.     private function PostVisitors($evaldRoot){
  396.         $visitors = array();
  397.         $visitors[] = new Less_Visitor_joinSelector();
  398.         if( self::$has_extends ){
  399.             $visitors[] = new Less_Visitor_processExtends();
  400.         }
  401.         $visitors[] = new Less_Visitor_toCSS();
  404.         if( Less_Parser::$options['plugins'] ){
  405.             foreach(Less_Parser::$options['plugins'] as $plugin){
  406.                 if( property_exists($plugin,'isPreEvalVisitor') && $plugin->isPreEvalVisitor ){
  407.                     continue;
  408.                 }
  410.                 if( property_exists($plugin,'isPreVisitor') && $plugin->isPreVisitor ){
  411.                     array_unshift( $visitors, $plugin);
  412.                 }else{
  413.                     $visitors[] = $plugin;
  414.                 }
  415.             }
  416.         }
  419.         for($i = 0; $i < count($visitors); $i++ ){
  420.             $visitors[$i]->run($evaldRoot);
  421.         }
  423.     }
  426.     /**
  427.      * Parse a Less string into css
  428.      *
  429.      * @param string $str The string to convert
  430.      * @param string $uri_root The url of the file
  431.      * @return Less_Tree_Ruleset|Less_Parser
  432.      */
  433.     public function parse( $str, $file_uri = null ){
  435.         if( !$file_uri ){
  436.             $uri_root = '';
  437.             $filename = 'anonymous-file-'.Less_Parser::$next_id++.'.less';
  438.         }else{
  439.             $file_uri = self::WinPath($file_uri);
  440.             $filename = $file_uri;
  441.             $uri_root = dirname($file_uri);
  442.         }
  444.         $previousFileInfo = $this->env->currentFileInfo;
  445.         $uri_root = self::WinPath($uri_root);
  446.         $this->SetFileInfo($filename, $uri_root);
  448.         $this->input = $str;
  449.         $this->_parse();
  451.         if( $previousFileInfo ){
  452.             $this->env->currentFileInfo = $previousFileInfo;
  453.         }
  455.         return $this;
  456.     }
  459.     /**
  460.      * Parse a Less string from a given file
  461.      *
  462.      * @throws Less_Exception_Parser
  463.      * @param string $filename The file to parse
  464.      * @param string $uri_root The url of the file
  465.      * @param bool $returnRoot Indicates whether the return value should be a css string a root node
  466.      * @return Less_Tree_Ruleset|Less_Parser
  467.      */
  468.     public function parseFile( $filename, $uri_root = '', $returnRoot = false){
  470.         if( !file_exists($filename) ){
  471.             $this->Error(sprintf('File `%s` not found.', $filename));
  472.         }
  475.         // fix uri_root?
  476.         // Instead of The mixture of file path for the first argument and directory path for the second argument has bee
  477.         if( !$returnRoot && !empty($uri_root) && basename($uri_root) == basename($filename) ){
  478.             $uri_root = dirname($uri_root);
  479.         }
  482.         $previousFileInfo = $this->env->currentFileInfo;
  485.         if( $filename ){
  486.             $filename = self::AbsPath($filename, true);
  487.         }
  488.         $uri_root = self::WinPath($uri_root);
  490.         $this->SetFileInfo($filename, $uri_root);
  492.         self::AddParsedFile($filename);
  494.         if( $returnRoot ){
  495.             $rules = $this->GetRules( $filename );
  496.             $return = new Less_Tree_Ruleset(array(), $rules );
  497.         }else{
  498.             $this->_parse( $filename );
  499.             $return = $this;
  500.         }
  502.         if( $previousFileInfo ){
  503.             $this->env->currentFileInfo = $previousFileInfo;
  504.         }
  506.         return $return;
  507.     }
  510.     /**
  511.      * Allows a user to set variables values
  512.      * @param array $vars
  513.      * @return Less_Parser
  514.      */
  515.     public function ModifyVars( $vars ){
  517.         $this->input = Less_Parser::serializeVars( $vars );
  518.         $this->_parse();
  520.         return $this;
  521.     }
  524.     /**
  525.      * @param string $filename
  526.      */
  527.     public function SetFileInfo( $filename, $uri_root = ''){
  529.         $filename = Less_Environment::normalizePath($filename);
  530.         $dirname = preg_replace('/[^\/\\\\]*$/','',$filename);
  532.         if( !empty($uri_root) ){
  533.             $uri_root = rtrim($uri_root,'/').'/';
  534.         }
  536.         $currentFileInfo = array();
  538.         //entry info
  539.         if( isset($this->env->currentFileInfo) ){
  540.             $currentFileInfo['entryPath'] = $this->env->currentFileInfo['entryPath'];
  541.             $currentFileInfo['entryUri'] = $this->env->currentFileInfo['entryUri'];
  542.             $currentFileInfo['rootpath'] = $this->env->currentFileInfo['rootpath'];
  544.         }else{
  545.             $currentFileInfo['entryPath'] = $dirname;
  546.             $currentFileInfo['entryUri'] = $uri_root;
  547.             $currentFileInfo['rootpath'] = $dirname;
  548.         }
  550.         $currentFileInfo['currentDirectory'] = $dirname;
  551.         $currentFileInfo['currentUri'] = $uri_root.basename($filename);
  552.         $currentFileInfo['filename'] = $filename;
  553.         $currentFileInfo['uri_root'] = $uri_root;
  556.         //inherit reference
  557.         if( isset($this->env->currentFileInfo['reference']) && $this->env->currentFileInfo['reference'] ){
  558.             $currentFileInfo['reference'] = true;
  559.         }
  561.         $this->env->currentFileInfo = $currentFileInfo;
  562.     }
  565.     /**
  566.      * @deprecated 1.5.1.2
  567.      *
  568.      */
  569.     public function SetCacheDir( $dir ){
  571.         if( !file_exists($dir) ){
  572.             if( mkdir($dir) ){
  573.                 return true;
  574.             }
  575.             throw new Less_Exception_Parser('Less.php cache directory couldn\'t be created: '.$dir);
  577.         }elseif( !is_dir($dir) ){
  578.             throw new Less_Exception_Parser('Less.php cache directory doesn\'t exist: '.$dir);
  580.         }elseif( !is_writable($dir) ){
  581.             throw new Less_Exception_Parser('Less.php cache directory isn\'t writable: '.$dir);
  583.         }else{
  584.             $dir = self::WinPath($dir);
  585.             Less_Cache::$cache_dir = rtrim($dir,'/').'/';
  586.             return true;
  587.         }
  588.     }
  591.     /**
  592.      * Set a list of directories or callbacks the parser should use for determining import paths
  593.      *
  594.      * @param array $dirs
  595.      */
  596.     public function SetImportDirs( $dirs ){
  597.         Less_Parser::$options['import_dirs'] = array();
  599.         foreach($dirs as $path => $uri_root){
  601.             $path = self::WinPath($path);
  602.             if( !empty($path) ){
  603.                 $path = rtrim($path,'/').'/';
  604.             }
  606.             if ( !is_callable($uri_root) ){
  607.                 $uri_root = self::WinPath($uri_root);
  608.                 if( !empty($uri_root) ){
  609.                     $uri_root = rtrim($uri_root,'/').'/';
  610.                 }
  611.             }
  613.             Less_Parser::$options['import_dirs'][$path] = $uri_root;
  614.         }
  615.     }
  617.     /**
  618.      * @param string $file_path
  619.      */
  620.     private function _parse( $file_path = null ){
  621.         $this->rules = array_merge($this->rules, $this->GetRules( $file_path ));
  622.     }
  625.     /**
  626.      * Return the results of parsePrimary for $file_path
  627.      * Use cache and save cached results if possible
  628.      *
  629.      * @param string|null $file_path
  630.      */
  631.     private function GetRules( $file_path ){
  633.         $this->SetInput($file_path);
  635.         $cache_file = $this->CacheFile( $file_path );
  636.         if( $cache_file ){
  637.             if( Less_Parser::$options['cache_method'] == 'callback' ){
  638.                 if( is_callable(Less_Parser::$options['cache_callback_get']) ){
  639.                     $cache = call_user_func_array(
  640.                         Less_Parser::$options['cache_callback_get'],
  641.                         array($this, $file_path, $cache_file)
  642.                     );
  644.                     if( $cache ){
  645.                         $this->UnsetInput();
  646.                         return $cache;
  647.                     }
  648.                 }
  650.             }elseif( file_exists($cache_file) ){
  651.                 switch(Less_Parser::$options['cache_method']){
  653.                     // Using serialize
  654.                     // Faster but uses more memory
  655.                     case 'serialize':
  656.                         $cache = unserialize(file_get_contents($cache_file));
  657.                         if( $cache ){
  658.                             touch($cache_file);
  659.                             $this->UnsetInput();
  660.                             return $cache;
  661.                         }
  662.                         break;
  665.                         // Using generated php code
  666.                     case 'var_export':
  667.                     case 'php':
  668.                         $this->UnsetInput();
  669.                         return include($cache_file);
  670.                 }
  671.             }
  672.         }
  674.         $rules = $this->parsePrimary();
  676.         if( $this->pos < $this->input_len ){
  677.             throw new Less_Exception_Chunk($this->input, null, $this->furthest, $this->env->currentFileInfo);
  678.         }
  680.         $this->UnsetInput();
  683.         //save the cache
  684.         if( $cache_file ){
  685.             if( Less_Parser::$options['cache_method'] == 'callback' ){
  686.                 if( is_callable(Less_Parser::$options['cache_callback_set']) ){
  687.                     call_user_func_array(
  688.                         Less_Parser::$options['cache_callback_set'],
  689.                         array($this, $file_path, $cache_file, $rules)
  690.                     );
  691.                 }
  693.             }else{
  694.                 //msg('write cache file');
  695.                 switch(Less_Parser::$options['cache_method']){
  696.                     case 'serialize':
  697.                         file_put_contents( $cache_file, serialize($rules) );
  698.                         break;
  699.                     case 'php':
  700.                         file_put_contents( $cache_file, '<?php return '.self::ArgString($rules).'; ?>' );
  701.                         break;
  702.                     case 'var_export':
  703.                         //Requires __set_state()
  704.                         file_put_contents( $cache_file, '<?php return '.var_export($rules,true).'; ?>' );
  705.                         break;
  706.                 }
  708.                 Less_Cache::CleanCache();
  709.             }
  710.         }
  712.         return $rules;
  713.     }
  716.     /**
  717.      * Set up the input buffer
  718.      *
  719.      */
  720.     public function SetInput( $file_path ){
  722.         if( $file_path ){
  723.             $this->input = file_get_contents( $file_path );
  724.         }
  726.         $this->pos = $this->furthest = 0;
  728.         // Remove potential UTF Byte Order Mark
  729.         $this->input = preg_replace('/\\G\xEF\xBB\xBF/', '', $this->input);
  730.         $this->input_len = strlen($this->input);
  733.         if( Less_Parser::$options['sourceMap'] && $this->env->currentFileInfo ){
  734.             $uri = $this->env->currentFileInfo['currentUri'];
  735.             Less_Parser::$contentsMap[$uri] = $this->input;
  736.         }
  738.     }
  741.     /**
  742.      * Free up some memory
  743.      *
  744.      */
  745.     public function UnsetInput(){
  746.         unset($this->input, $this->pos, $this->input_len, $this->furthest);
  747.         $this->saveStack = array();
  748.     }
  751.     public function CacheFile( $file_path ){
  753.         if( $file_path && $this->CacheEnabled() ){
  755.             $env = get_object_vars($this->env);
  756.             unset($env['frames']);
  758.             $parts = array();
  759.             $parts[] = $file_path;
  760.             $parts[] = filesize( $file_path );
  761.             $parts[] = filemtime( $file_path );
  762.             $parts[] = $env;
  763.             $parts[] = Less_Version::cache_version;
  764.             $parts[] = Less_Parser::$options['cache_method'];
  765.             return Less_Cache::$cache_dir . Less_Cache::$prefix . base_convert( sha1(json_encode($parts) ), 16, 36) . '.lesscache';
  766.         }
  767.     }
  770.     static function AddParsedFile($file){
  771.         self::$imports[] = $file;
  772.     }
  774.     static function AllParsedFiles(){
  775.         return self::$imports;
  776.     }
  778.     /**
  779.      * @param string $file
  780.      */
  781.     static function FileParsed($file){
  782.         return in_array($file,self::$imports);
  783.     }
  786.     function save() {
  787.         $this->saveStack[] = $this->pos;
  788.     }
  790.     private function restore() {
  791.         $this->pos = array_pop($this->saveStack);
  792.     }
  794.     private function forget(){
  795.         array_pop($this->saveStack);
  796.     }
  798.     /**
  799.      * Determine if the character at the specified offset from the current position is a white space.
  800.      *
  801.      * @param int $offset
  802.      *
  803.      * @return bool
  804.      */
  805.     private function isWhitespace($offset = 0) {
  806.         return strpos(" \t\n\r\v\f", $this->input[$this->pos + $offset]) !== false;
  807.     }
  809.     /**
  810.      * Parse from a token, regexp or string, and move forward if match
  811.      *
  812.      * @param array $toks
  813.      * @return array
  814.      */
  815.     private function match($toks){
  817.         // The match is confirmed, add the match length to `this::pos`,
  818.         // and consume any extra white-space characters (' ' || '\n')
  819.         // which come after that. The reason for this is that LeSS's
  820.         // grammar is mostly white-space insensitive.
  821.         //
  823.         foreach($toks as $tok){
  825.             $char = $tok[0];
  827.             if( $char === '/' ){
  828.                 $match = $this->MatchReg($tok);
  830.                 if( $match ){
  831.                     return count($match) === 1 ? $match[0] : $match;
  832.                 }
  834.             }elseif( $char === '#' ){
  835.                 $match = $this->MatchChar($tok[1]);
  837.             }else{
  838.                 // Non-terminal, match using a function call
  839.                 $match = $this->$tok();
  841.             }
  843.             if( $match ){
  844.                 return $match;
  845.             }
  846.         }
  847.     }
  849.     /**
  850.      * @param string[] $toks
  851.      *
  852.      * @return string
  853.      */
  854.     private function MatchFuncs($toks){
  856.         if( $this->pos < $this->input_len ){
  857.             foreach($toks as $tok){
  858.                 $match = $this->$tok();
  859.                 if( $match ){
  860.                     return $match;
  861.                 }
  862.             }
  863.         }
  865.     }
  867.     // Match a single character in the input,
  868.     private function MatchChar($tok){
  869.         if( ($this->pos < $this->input_len) && ($this->input[$this->pos] === $tok) ){
  870.             $this->skipWhitespace(1);
  871.             return $tok;
  872.         }
  873.     }
  875.     // Match a regexp from the current start point
  876.     private function MatchReg($tok){
  878.         if( preg_match($tok, $this->input, $match, 0, $this->pos) ){
  879.             $this->skipWhitespace(strlen($match[0]));
  880.             return $match;
  881.         }
  882.     }
  885.     /**
  886.      * Same as match(), but don't change the state of the parser,
  887.      * just return the match.
  888.      *
  889.      * @param string $tok
  890.      * @return integer
  891.      */
  892.     public function PeekReg($tok){
  893.         return preg_match($tok, $this->input, $match, 0, $this->pos);
  894.     }
  896.     /**
  897.      * @param string $tok
  898.      */
  899.     public function PeekChar($tok){
  900.         //return ($this->input[$this->pos] === $tok );
  901.         return ($this->pos < $this->input_len) && ($this->input[$this->pos] === $tok );
  902.     }
  905.     /**
  906.      * @param integer $length
  907.      */
  908.     public function skipWhitespace($length){
  910.         $this->pos += $length;
  912.         for(; $this->pos < $this->input_len; $this->pos++ ){
  913.             $c = $this->input[$this->pos];
  915.             if( ($c !== "\n") && ($c !== "\r") && ($c !== "\t") && ($c !== ' ') ){
  916.                 break;
  917.             }
  918.         }
  919.     }
  922.     /**
  923.      * @param string $tok
  924.      * @param string|null $msg
  925.      */
  926.     public function expect($tok, $msg = NULL) {
  927.         $result = $this->match( array($tok) );
  928.         if (!$result) {
  929.             $this->Error( $msg    ? "Expected '" . $tok . "' got '" . $this->input[$this->pos] . "'" : $msg );
  930.         } else {
  931.             return $result;
  932.         }
  933.     }
  935.     /**
  936.      * @param string $tok
  937.      */
  938.     public function expectChar($tok, $msg = null ){
  939.         $result = $this->MatchChar($tok);
  940.         if( !$result ){
  941.             $msg = $msg ? $msg : "Expected '" . $tok . "' got '" . $this->input[$this->pos] . "'";
  942.             $this->Error( $msg );
  943.         }else{
  944.             return $result;
  945.         }
  946.     }
  948.     //
  949.     // Here in, the parsing rules/functions
  950.     //
  951.     // The basic structure of the syntax tree generated is as follows:
  952.     //
  953.     //   Ruleset ->  Rule -> Value -> Expression -> Entity
  954.     //
  955.     // Here's some LESS code:
  956.     //
  957.     //    .class {
  958.     //      color: #fff;
  959.     //      border: 1px solid #000;
  960.     //      width: @w + 4px;
  961.     //      > .child {...}
  962.     //    }
  963.     //
  964.     // And here's what the parse tree might look like:
  965.     //
  966.     //     Ruleset (Selector '.class', [
  967.     //         Rule ("color",  Value ([Expression [Color #fff]]))
  968.     //         Rule ("border", Value ([Expression [Dimension 1px][Keyword "solid"][Color #000]]))
  969.     //         Rule ("width",  Value ([Expression [Operation "+" [Variable "@w"][Dimension 4px]]]))
  970.     //         Ruleset (Selector [Element '>', '.child'], [...])
  971.     //     ])
  972.     //
  973.     //  In general, most rules will try to parse a token with the `$()` function, and if the return
  974.     //  value is truly, will return a new node, of the relevant type. Sometimes, we need to check
  975.     //  first, before parsing, that's when we use `peek()`.
  976.     //
  978.     //
  979.     // The `primary` rule is the *entry* and *exit* point of the parser.
  980.     // The rules here can appear at any level of the parse tree.
  981.     //
  982.     // The recursive nature of the grammar is an interplay between the `block`
  983.     // rule, which represents `{ ... }`, the `ruleset` rule, and this `primary` rule,
  984.     // as represented by this simplified grammar:
  985.     //
  986.     //     primary  â†’  (ruleset | rule)+
  987.     //     ruleset  â†’  selector+ block
  988.     //     block    â†’  '{' primary '}'
  989.     //
  990.     // Only at one point is the primary rule not called from the
  991.     // block rule: at the root level.
  992.     //
  993.     private function parsePrimary(){
  994.         $root = array();
  996.         while( true ){
  998.             if( $this->pos >= $this->input_len ){
  999.                 break;
  1000.             }
  1002.             $node = $this->parseExtend(true);
  1003.             if( $node ){
  1004.                 $root = array_merge($root,$node);
  1005.                 continue;
  1006.             }
  1008.             //$node = $this->MatchFuncs( array( 'parseMixinDefinition', 'parseRule', 'parseRuleset', 'parseMixinCall', 'parseComment', 'parseDirective'));
  1009.             $node = $this->MatchFuncs( array( 'parseMixinDefinition', 'parseNameValue', 'parseRule', 'parseRuleset', 'parseMixinCall', 'parseComment', 'parseRulesetCall', 'parseDirective'));
  1011.             if( $node ){
  1012.                 $root[] = $node;
  1013.             }elseif( !$this->MatchReg('/\\G[\s\n;]+/') ){
  1014.                 break;
  1015.             }
  1017.             if( $this->PeekChar('}') ){
  1018.                 break;
  1019.             }
  1020.         }
  1022.         return $root;
  1023.     }
  1027.     // We create a Comment node for CSS comments `/* */`,
  1028.     // but keep the LeSS comments `//` silent, by just skipping
  1029.     // over them.
  1030.     private function parseComment(){
  1032.         if( $this->input[$this->pos] !== '/' ){
  1033.             return;
  1034.         }
  1036.         if( $this->input[$this->pos+1] === '/' ){
  1037.             $match = $this->MatchReg('/\\G\/\/.*/');
  1038.             return $this->NewObj4('Less_Tree_Comment',array($match[0], true, $this->pos, $this->env->currentFileInfo));
  1039.         }
  1041.         //$comment = $this->MatchReg('/\\G\/\*(?:[^*]|\*+[^\/*])*\*+\/\n?/');
  1042.         $comment = $this->MatchReg('/\\G\/\*(?s).*?\*+\/\n?/');//not the same as less.js to prevent fatal errors
  1043.         if( $comment ){
  1044.             return $this->NewObj4('Less_Tree_Comment',array($comment[0], false, $this->pos, $this->env->currentFileInfo));
  1045.         }
  1046.     }
  1048.     private function parseComments(){
  1049.         $comments = array();
  1051.         while( $this->pos < $this->input_len ){
  1052.             $comment = $this->parseComment();
  1053.             if( !$comment ){
  1054.                 break;
  1055.             }
  1057.             $comments[] = $comment;
  1058.         }
  1060.         return $comments;
  1061.     }
  1065.     //
  1066.     // A string, which supports escaping " and '
  1067.     //
  1068.     //     "milky way" 'he\'s the one!'
  1069.     //
  1070.     private function parseEntitiesQuoted() {
  1071.         $j = $this->pos;
  1072.         $e = false;
  1073.         $index = $this->pos;
  1075.         if( $this->input[$this->pos] === '~' ){
  1076.             $j++;
  1077.             $e = true; // Escaped strings
  1078.         }
  1080.         $char = $this->input[$j];
  1081.         if( $char !== '"' && $char !== "'" ){
  1082.             return;
  1083.         }
  1085.         if ($e) {
  1086.             $this->MatchChar('~');
  1087.         }
  1090.         $matched = $this->MatchQuoted($char, $j+1);
  1091.         if( $matched === false ){
  1092.             return;
  1093.         }
  1095.         $quoted = $char.$matched.$char;
  1096.         return $this->NewObj5('Less_Tree_Quoted',array($quoted, $matched, $e, $index, $this->env->currentFileInfo) );
  1097.     }
  1100.     /**
  1101.      * When PCRE JIT is enabled in php, regular expressions don't work for matching quoted strings
  1102.      *
  1103.      *    $regex    = '/\\G\'((?:[^\'\\\\\r\n]|\\\\.|\\\\\r\n|\\\\[\n\r\f])*)\'/';
  1104.      *    $regex    = '/\\G"((?:[^"\\\\\r\n]|\\\\.|\\\\\r\n|\\\\[\n\r\f])*)"/';
  1105.      *
  1106.      */
  1107.     private function MatchQuoted($quote_char, $i){
  1109.         $matched = '';
  1110.         while( $i < $this->input_len ){
  1111.             $c = $this->input[$i];
  1113.             //escaped character
  1114.             if( $c === '\\' ){
  1115.                 $matched .= $c . $this->input[$i+1];
  1116.                 $i += 2;
  1117.                 continue;
  1118.             }
  1120.             if( $c === $quote_char ){
  1121.                 $this->pos = $i+1;
  1122.                 $this->skipWhitespace(0);
  1123.                 return $matched;
  1124.             }
  1126.             if( $c === "\r" || $c === "\n" ){
  1127.                 return false;
  1128.             }
  1130.             $i++;
  1131.             $matched .= $c;
  1132.         }
  1134.         return false;
  1135.     }
  1138.     //
  1139.     // A catch-all word, such as:
  1140.     //
  1141.     //     black border-collapse
  1142.     //
  1143.     private function parseEntitiesKeyword(){
  1145.         //$k = $this->MatchReg('/\\G[_A-Za-z-][_A-Za-z0-9-]*/');
  1146.         $k = $this->MatchReg('/\\G%|\\G[_A-Za-z-][_A-Za-z0-9-]*/');
  1147.         if( $k ){
  1148.             $k = $k[0];
  1149.             $color = $this->fromKeyword($k);
  1150.             if( $color ){
  1151.                 return $color;
  1152.             }
  1153.             return $this->NewObj1('Less_Tree_Keyword',$k);
  1154.         }
  1155.     }
  1157.     // duplicate of Less_Tree_Color::FromKeyword
  1158.     private function FromKeyword( $keyword ){
  1159.         $keyword = strtolower($keyword);
  1161.         if( Less_Colors::hasOwnProperty($keyword) ){
  1162.             // detect named color
  1163.             return $this->NewObj1('Less_Tree_Color',substr(Less_Colors::color($keyword), 1));
  1164.         }
  1166.         if( $keyword === 'transparent' ){
  1167.             return $this->NewObj3('Less_Tree_Color', array( array(0, 0, 0), 0, true));
  1168.         }
  1169.     }
  1171.     //
  1172.     // A function call
  1173.     //
  1174.     //     rgb(255, 0, 255)
  1175.     //
  1176.     // We also try to catch IE's `alpha()`, but let the `alpha` parser
  1177.     // deal with the details.
  1178.     //
  1179.     // The arguments are parsed with the `entities.arguments` parser.
  1180.     //
  1181.     private function parseEntitiesCall(){
  1182.         $index = $this->pos;
  1184.         if( !preg_match('/\\G([\w-]+|%|progid:[\w\.]+)\(/', $this->input, $name,0,$this->pos) ){
  1185.             return;
  1186.         }
  1187.         $name = $name[1];
  1188.         $nameLC = strtolower($name);
  1190.         if ($nameLC === 'url') {
  1191.             return null;
  1192.         }
  1194.         $this->pos += strlen($name);
  1196.         if( $nameLC === 'alpha' ){
  1197.             $alpha_ret = $this->parseAlpha();
  1198.             if( $alpha_ret ){
  1199.                 return $alpha_ret;
  1200.             }
  1201.         }
  1203.         $this->MatchChar('('); // Parse the '(' and consume whitespace.
  1205.         $args = $this->parseEntitiesArguments();
  1207.         if( !$this->MatchChar(')') ){
  1208.             return;
  1209.         }
  1211.         if ($name) {
  1212.             return $this->NewObj4('Less_Tree_Call',array($name, $args, $index, $this->env->currentFileInfo) );
  1213.         }
  1214.     }
  1216.     /**
  1217.      * Parse a list of arguments
  1218.      *
  1219.      * @return array
  1220.      */
  1221.     private function parseEntitiesArguments(){
  1223.         $args = array();
  1224.         while( true ){
  1225.             $arg = $this->MatchFuncs( array('parseEntitiesAssignment','parseExpression') );
  1226.             if( !$arg ){
  1227.                 break;
  1228.             }
  1230.             $args[] = $arg;
  1231.             if( !$this->MatchChar(',') ){
  1232.                 break;
  1233.             }
  1234.         }
  1235.         return $args;
  1236.     }
  1238.     private function parseEntitiesLiteral(){
  1239.         return $this->MatchFuncs( array('parseEntitiesDimension','parseEntitiesColor','parseEntitiesQuoted','parseUnicodeDescriptor') );
  1240.     }
  1242.     // Assignments are argument entities for calls.
  1243.     // They are present in ie filter properties as shown below.
  1244.     //
  1245.     //     filter: progid:DXImageTransform.Microsoft.Alpha( *opacity=50* )
  1246.     //
  1247.     private function parseEntitiesAssignment() {
  1249.         $key = $this->MatchReg('/\\G\w+(?=\s?=)/');
  1250.         if( !$key ){
  1251.             return;
  1252.         }
  1254.         if( !$this->MatchChar('=') ){
  1255.             return;
  1256.         }
  1258.         $value = $this->parseEntity();
  1259.         if( $value ){
  1260.             return $this->NewObj2('Less_Tree_Assignment',array($key[0], $value));
  1261.         }
  1262.     }
  1264.     //
  1265.     // Parse url() tokens
  1266.     //
  1267.     // We use a specific rule for urls, because they don't really behave like
  1268.     // standard function calls. The difference is that the argument doesn't have
  1269.     // to be enclosed within a string, so it can't be parsed as an Expression.
  1270.     //
  1271.     private function parseEntitiesUrl(){
  1274.         if( $this->input[$this->pos] !== 'u' || !$this->matchReg('/\\Gurl\(/') ){
  1275.             return;
  1276.         }
  1278.         $value = $this->match( array('parseEntitiesQuoted','parseEntitiesVariable','/\\Gdata\:.*?[^\)]+/','/\\G(?:(?:\\\\[\(\)\'"])|[^\(\)\'"])+/') );
  1279.         if( !$value ){
  1280.             $value = '';
  1281.         }
  1284.         $this->expectChar(')');
  1287.         if( isset($value->value) || $value instanceof Less_Tree_Variable ){
  1288.             return $this->NewObj2('Less_Tree_Url',array($value, $this->env->currentFileInfo));
  1289.         }
  1291.         return $this->NewObj2('Less_Tree_Url', array( $this->NewObj1('Less_Tree_Anonymous',$value), $this->env->currentFileInfo) );
  1292.     }
  1295.     //
  1296.     // A Variable entity, such as `@fink`, in
  1297.     //
  1298.     //     width: @fink + 2px
  1299.     //
  1300.     // We use a different parser for variable definitions,
  1301.     // see `parsers.variable`.
  1302.     //
  1303.     private function parseEntitiesVariable(){
  1304.         $index = $this->pos;
  1305.         if ($this->PeekChar('@') && ($name = $this->MatchReg('/\\G@@?[\w-]+/'))) {
  1306.             return $this->NewObj3('Less_Tree_Variable', array( $name[0], $index, $this->env->currentFileInfo));
  1307.         }
  1308.     }
  1311.     // A variable entity using the protective {} e.g. @{var}
  1312.     private function parseEntitiesVariableCurly() {
  1313.         $index = $this->pos;
  1315.         if( $this->input_len > ($this->pos+1) && $this->input[$this->pos] === '@' && ($curly = $this->MatchReg('/\\G@\{([\w-]+)\}/')) ){
  1316.             return $this->NewObj3('Less_Tree_Variable',array('@'.$curly[1], $index, $this->env->currentFileInfo));
  1317.         }
  1318.     }
  1320.     //
  1321.     // A Hexadecimal color
  1322.     //
  1323.     //     #4F3C2F
  1324.     //
  1325.     // `rgb` and `hsl` colors are parsed through the `entities.call` parser.
  1326.     //
  1327.     private function parseEntitiesColor(){
  1328.         if ($this->PeekChar('#') && ($rgb = $this->MatchReg('/\\G#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})/'))) {
  1329.             return $this->NewObj1('Less_Tree_Color',$rgb[1]);
  1330.         }
  1331.     }
  1333.     //
  1334.     // A Dimension, that is, a number and a unit
  1335.     //
  1336.     //     0.5em 95%
  1337.     //
  1338.     private function parseEntitiesDimension(){
  1340.         $c = @ord($this->input[$this->pos]);
  1342.         //Is the first char of the dimension 0-9, '.', '+' or '-'
  1343.         if (($c > 57 || $c < 43) || $c === 47 || $c == 44){
  1344.             return;
  1345.         }
  1347.         $value = $this->MatchReg('/\\G([+-]?\d*\.?\d+)(%|[a-z]+)?/');
  1348.         if( $value ){
  1350.             if( isset($value[2]) ){
  1351.                 return $this->NewObj2('Less_Tree_Dimension', array($value[1],$value[2]));
  1352.             }
  1353.             return $this->NewObj1('Less_Tree_Dimension',$value[1]);
  1354.         }
  1355.     }
  1358.     //
  1359.     // A unicode descriptor, as is used in unicode-range
  1360.     //
  1361.     // U+0?? or U+00A1-00A9
  1362.     //
  1363.     function parseUnicodeDescriptor() {
  1364.         $ud = $this->MatchReg('/\\G(U\+[0-9a-fA-F?]+)(\-[0-9a-fA-F?]+)?/');
  1365.         if( $ud ){
  1366.             return $this->NewObj1('Less_Tree_UnicodeDescriptor', $ud[0]);
  1367.         }
  1368.     }
  1371.     //
  1372.     // JavaScript code to be evaluated
  1373.     //
  1374.     //     `window.location.href`
  1375.     //
  1376.     private function parseEntitiesJavascript(){
  1377.         $e = false;
  1378.         $j = $this->pos;
  1379.         if( $this->input[$j] === '~' ){
  1380.             $j++;
  1381.             $e = true;
  1382.         }
  1383.         if( $this->input[$j] !== '`' ){
  1384.             return;
  1385.         }
  1386.         if( $e ){
  1387.             $this->MatchChar('~');
  1388.         }
  1389.         $str = $this->MatchReg('/\\G`([^`]*)`/');
  1390.         if( $str ){
  1391.             return $this->NewObj3('Less_Tree_Javascript', array($str[1], $this->pos, $e));
  1392.         }
  1393.     }
  1396.     //
  1397.     // The variable part of a variable definition. Used in the `rule` parser
  1398.     //
  1399.     //     @fink:
  1400.     //
  1401.     private function parseVariable(){
  1402.         if ($this->PeekChar('@') && ($name = $this->MatchReg('/\\G(@[\w-]+)\s*:/'))) {
  1403.             return $name[1];
  1404.         }
  1405.     }
  1408.     //
  1409.     // The variable part of a variable definition. Used in the `rule` parser
  1410.     //
  1411.     // @fink();
  1412.     //
  1413.     private function parseRulesetCall(){
  1415.         if( $this->input[$this->pos] === '@' && ($name = $this->MatchReg('/\\G(@[\w-]+)\s*\(\s*\)\s*;/')) ){
  1416.             return $this->NewObj1('Less_Tree_RulesetCall', $name[1] );
  1417.         }
  1418.     }
  1421.     //
  1422.     // extend syntax - used to extend selectors
  1423.     //
  1424.     function parseExtend($isRule = false){
  1426.         $index = $this->pos;
  1427.         $extendList = array();
  1430.         if( !$this->MatchReg( $isRule ? '/\\G&:extend\(/' : '/\\G:extend\(/' ) ){ return; }
  1432.         do{
  1433.             $option = null;
  1434.             $elements = array();
  1435.             while( true ){
  1436.                 $option = $this->MatchReg('/\\G(all)(?=\s*(\)|,))/');
  1437.                 if( $option ){ break; }
  1438.                 $e = $this->parseElement();
  1439.                 if( !$e ){ break; }
  1440.                 $elements[] = $e;
  1441.             }
  1443.             if( $option ){
  1444.                 $option = $option[1];
  1445.             }
  1447.             $extendList[] = $this->NewObj3('Less_Tree_Extend', array( $this->NewObj1('Less_Tree_Selector',$elements), $option, $index ));
  1449.         }while( $this->MatchChar(",") );
  1451.         $this->expect('/\\G\)/');
  1453.         if( $isRule ){
  1454.             $this->expect('/\\G;/');
  1455.         }
  1457.         return $extendList;
  1458.     }
  1461.     //
  1462.     // A Mixin call, with an optional argument list
  1463.     //
  1464.     //     #mixins > .square(#fff);
  1465.     //     .rounded(4px, black);
  1466.     //     .button;
  1467.     //
  1468.     // The `while` loop is there because mixins can be
  1469.     // namespaced, but we only support the child and descendant
  1470.     // selector for now.
  1471.     //
  1472.     private function parseMixinCall(){
  1474.         $char = $this->input[$this->pos];
  1475.         if( $char !== '.' && $char !== '#' ){
  1476.             return;
  1477.         }
  1479.         $index = $this->pos;
  1480.         $this->save(); // stop us absorbing part of an invalid selector
  1482.         $elements = $this->parseMixinCallElements();
  1484.         if( $elements ){
  1486.             if( $this->MatchChar('(') ){
  1487.                 $returned = $this->parseMixinArgs(true);
  1488.                 $args = $returned['args'];
  1489.                 $this->expectChar(')');
  1490.             }else{
  1491.                 $args = array();
  1492.             }
  1494.             $important = $this->parseImportant();
  1496.             if( $this->parseEnd() ){
  1497.                 $this->forget();
  1498.                 return $this->NewObj5('Less_Tree_Mixin_Call', array( $elements, $args, $index, $this->env->currentFileInfo, $important));
  1499.             }
  1500.         }
  1502.         $this->restore();
  1503.     }
  1506.     private function parseMixinCallElements(){
  1507.         $elements = array();
  1508.         $c = null;
  1510.         while( true ){
  1511.             $elemIndex = $this->pos;
  1512.             $e = $this->MatchReg('/\\G[#.](?:[\w-]|\\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/');
  1513.             if( !$e ){
  1514.                 break;
  1515.             }
  1516.             $elements[] = $this->NewObj4('Less_Tree_Element', array($c, $e[0], $elemIndex, $this->env->currentFileInfo));
  1517.             $c = $this->MatchChar('>');
  1518.         }
  1520.         return $elements;
  1521.     }
  1525.     /**
  1526.      * @param boolean $isCall
  1527.      */
  1528.     private function parseMixinArgs( $isCall ){
  1529.         $expressions = array();
  1530.         $argsSemiColon = array();
  1531.         $isSemiColonSeperated = null;
  1532.         $argsComma = array();
  1533.         $expressionContainsNamed = null;
  1534.         $name = null;
  1535.         $returner = array('args'=>array(), 'variadic'=> false);
  1537.         $this->save();
  1539.         while( true ){
  1540.             if( $isCall ){
  1541.                 $arg = $this->MatchFuncs( array( 'parseDetachedRuleset','parseExpression' ) );
  1542.             } else {
  1543.                 $this->parseComments();
  1544.                 if( $this->input[ $this->pos ] === '.' && $this->MatchReg('/\\G\.{3}/') ){
  1545.                     $returner['variadic'] = true;
  1546.                     if( $this->MatchChar(";") && !$isSemiColonSeperated ){
  1547.                         $isSemiColonSeperated = true;
  1548.                     }
  1550.                     if( $isSemiColonSeperated ){
  1551.                         $argsSemiColon[] = array('variadic'=>true);
  1552.                     }else{
  1553.                         $argsComma[] = array('variadic'=>true);
  1554.                     }
  1555.                     break;
  1556.                 }
  1557.                 $arg = $this->MatchFuncs( array('parseEntitiesVariable','parseEntitiesLiteral','parseEntitiesKeyword') );
  1558.             }
  1560.             if( !$arg ){
  1561.                 break;
  1562.             }
  1565.             $nameLoop = null;
  1566.             if( $arg instanceof Less_Tree_Expression ){
  1567.                 $arg->throwAwayComments();
  1568.             }
  1569.             $value = $arg;
  1570.             $val = null;
  1572.             if( $isCall ){
  1573.                 // Variable
  1574.                 if( property_exists($arg,'value') && count($arg->value) == 1 ){
  1575.                     $val = $arg->value[0];
  1576.                 }
  1577.             } else {
  1578.                 $val = $arg;
  1579.             }
  1582.             if( $val instanceof Less_Tree_Variable ){
  1584.                 if( $this->MatchChar(':') ){
  1585.                     if( $expressions ){
  1586.                         if( $isSemiColonSeperated ){
  1587.                             $this->Error('Cannot mix ; and , as delimiter types');
  1588.                         }
  1589.                         $expressionContainsNamed = true;
  1590.                     }
  1592.                     // we do not support setting a ruleset as a default variable - it doesn't make sense
  1593.                     // However if we do want to add it, there is nothing blocking it, just don't error
  1594.                     // and remove isCall dependency below
  1595.                     $value = null;
  1596.                     if( $isCall ){
  1597.                         $value = $this->parseDetachedRuleset();
  1598.                     }
  1599.                     if( !$value ){
  1600.                         $value = $this->parseExpression();
  1601.                     }
  1603.                     if( !$value ){
  1604.                         if( $isCall ){
  1605.                             $this->Error('could not understand value for named argument');
  1606.                         } else {
  1607.                             $this->restore();
  1608.                             $returner['args'] = array();
  1609.                             return $returner;
  1610.                         }
  1611.                     }
  1613.                     $nameLoop = ($name = $val->name);
  1614.                 }elseif( !$isCall && $this->MatchReg('/\\G\.{3}/') ){
  1615.                     $returner['variadic'] = true;
  1616.                     if( $this->MatchChar(";") && !$isSemiColonSeperated ){
  1617.                         $isSemiColonSeperated = true;
  1618.                     }
  1619.                     if( $isSemiColonSeperated ){
  1620.                         $argsSemiColon[] = array('name'=> $arg->name, 'variadic' => true);
  1621.                     }else{
  1622.                         $argsComma[] = array('name'=> $arg->name, 'variadic' => true);
  1623.                     }
  1624.                     break;
  1625.                 }elseif( !$isCall ){
  1626.                     $name = $nameLoop = $val->name;
  1627.                     $value = null;
  1628.                 }
  1629.             }
  1631.             if( $value ){
  1632.                 $expressions[] = $value;
  1633.             }
  1635.             $argsComma[] = array('name'=>$nameLoop, 'value'=>$value );
  1637.             if( $this->MatchChar(',') ){
  1638.                 continue;
  1639.             }
  1641.             if( $this->MatchChar(';') || $isSemiColonSeperated ){
  1643.                 if( $expressionContainsNamed ){
  1644.                     $this->Error('Cannot mix ; and , as delimiter types');
  1645.                 }
  1647.                 $isSemiColonSeperated = true;
  1649.                 if( count($expressions) > 1 ){
  1650.                     $value = $this->NewObj1('Less_Tree_Value', $expressions);
  1651.                 }
  1652.                 $argsSemiColon[] = array('name'=>$name, 'value'=>$value );
  1654.                 $name = null;
  1655.                 $expressions = array();
  1656.                 $expressionContainsNamed = false;
  1657.             }
  1658.         }
  1660.         $this->forget();
  1661.         $returner['args'] = ($isSemiColonSeperated ? $argsSemiColon : $argsComma);
  1662.         return $returner;
  1663.     }
  1667.     //
  1668.     // A Mixin definition, with a list of parameters
  1669.     //
  1670.     //     .rounded (@radius: 2px, @color) {
  1671.     //        ...
  1672.     //     }
  1673.     //
  1674.     // Until we have a finer grained state-machine, we have to
  1675.     // do a look-ahead, to make sure we don't have a mixin call.
  1676.     // See the `rule` function for more information.
  1677.     //
  1678.     // We start by matching `.rounded (`, and then proceed on to
  1679.     // the argument list, which has optional default values.
  1680.     // We store the parameters in `params`, with a `value` key,
  1681.     // if there is a value, such as in the case of `@radius`.
  1682.     //
  1683.     // Once we've got our params list, and a closing `)`, we parse
  1684.     // the `{...}` block.
  1685.     //
  1686.     private function parseMixinDefinition(){
  1687.         $cond = null;
  1689.         $char = $this->input[$this->pos];
  1690.         if( ($char !== '.' && $char !== '#') || ($char === '{' && $this->PeekReg('/\\G[^{]*\}/')) ){
  1691.             return;
  1692.         }
  1694.         $this->save();
  1696.         $match = $this->MatchReg('/\\G([#.](?:[\w-]|\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+)\s*\(/');
  1697.         if( $match ){
  1698.             $name = $match[1];
  1700.             $argInfo = $this->parseMixinArgs( false );
  1701.             $params = $argInfo['args'];
  1702.             $variadic = $argInfo['variadic'];
  1705.             // .mixincall("@{a}");
  1706.             // looks a bit like a mixin definition..
  1707.             // also
  1708.             // .mixincall(@a: {rule: set;});
  1709.             // so we have to be nice and restore
  1710.             if( !$this->MatchChar(')') ){
  1711.                 $this->furthest = $this->pos;
  1712.                 $this->restore();
  1713.                 return;
  1714.             }
  1717.             $this->parseComments();
  1719.             if ($this->MatchReg('/\\Gwhen/')) { // Guard
  1720.                 $cond = $this->expect('parseConditions', 'Expected conditions');
  1721.             }
  1723.             $ruleset = $this->parseBlock();
  1725.             if( is_array($ruleset) ){
  1726.                 $this->forget();
  1727.                 return $this->NewObj5('Less_Tree_Mixin_Definition', array( $name, $params, $ruleset, $cond, $variadic));
  1728.             }
  1730.             $this->restore();
  1731.         }else{
  1732.             $this->forget();
  1733.         }
  1734.     }
  1736.     //
  1737.     // Entities are the smallest recognized token,
  1738.     // and can be found inside a rule's value.
  1739.     //
  1740.     private function parseEntity(){
  1742.         return $this->MatchFuncs( array('parseEntitiesLiteral','parseEntitiesVariable','parseEntitiesUrl','parseEntitiesCall','parseEntitiesKeyword','parseEntitiesJavascript','parseComment') );
  1743.     }
  1745.     //
  1746.     // A Rule terminator. Note that we use `peek()` to check for '}',
  1747.     // because the `block` rule will be expecting it, but we still need to make sure
  1748.     // it's there, if ';' was omitted.
  1749.     //
  1750.     private function parseEnd(){
  1751.         return $this->MatchChar(';') || $this->PeekChar('}');
  1752.     }
  1754.     //
  1755.     // IE's alpha function
  1756.     //
  1757.     //     alpha(opacity=88)
  1758.     //
  1759.     private function parseAlpha(){
  1761.         if ( ! $this->MatchReg('/\\G\(opacity=/i')) {
  1762.             return;
  1763.         }
  1765.         $value = $this->MatchReg('/\\G[0-9]+/');
  1766.         if( $value ){
  1767.             $value = $value[0];
  1768.         }else{
  1769.             $value = $this->parseEntitiesVariable();
  1770.             if( !$value ){
  1771.                 return;
  1772.             }
  1773.         }
  1775.         $this->expectChar(')');
  1776.         return $this->NewObj1('Less_Tree_Alpha',$value);
  1777.     }
  1780.     //
  1781.     // A Selector Element
  1782.     //
  1783.     //     div
  1784.     //     + h1
  1785.     //     #socks
  1786.     //     input[type="text"]
  1787.     //
  1788.     // Elements are the building blocks for Selectors,
  1789.     // they are made out of a `Combinator` (see combinator rule),
  1790.     // and an element name, such as a tag a class, or `*`.
  1791.     //
  1792.     private function parseElement(){
  1793.         $c = $this->parseCombinator();
  1794.         $index = $this->pos;
  1796.         $e = $this->match( array('/\\G(?:\d+\.\d+|\d+)%/', '/\\G(?:[.#]?|:*)(?:[\w-]|[^\x00-\x9f]|\\\\(?:[A-Fa-f0-9]{1,6} ?|[^A-Fa-f0-9]))+/',
  1797.             '#*', '#&', 'parseAttribute', '/\\G\([^()@]+\)/', '/\\G[\.#](?=@)/', 'parseEntitiesVariableCurly') );
  1799.         if( is_null($e) ){
  1800.             $this->save();
  1801.             if( $this->MatchChar('(') ){
  1802.                 if( ($v = $this->parseSelector()) && $this->MatchChar(')') ){
  1803.                     $e = $this->NewObj1('Less_Tree_Paren',$v);
  1804.                     $this->forget();
  1805.                 }else{
  1806.                     $this->restore();
  1807.                 }
  1808.             }else{
  1809.                 $this->forget();
  1810.             }
  1811.         }
  1813.         if( !is_null($e) ){
  1814.             return $this->NewObj4('Less_Tree_Element',array( $c, $e, $index, $this->env->currentFileInfo));
  1815.         }
  1816.     }
  1818.     //
  1819.     // Combinators combine elements together, in a Selector.
  1820.     //
  1821.     // Because our parser isn't white-space sensitive, special care
  1822.     // has to be taken, when parsing the descendant combinator, ` `,
  1823.     // as it's an empty space. We have to check the previous character
  1824.     // in the input, to see if it's a ` ` character.
  1825.     //
  1826.     private function parseCombinator(){
  1827.         if( $this->pos < $this->input_len ){
  1828.             $c = $this->input[$this->pos];
  1829.             if ($c === '>' || $c === '+' || $c === '~' || $c === '|' || $c === '^' ){
  1831.                 $this->pos++;
  1832.                 if( $this->input[$this->pos] === '^' ){
  1833.                     $c = '^^';
  1834.                     $this->pos++;
  1835.                 }
  1837.                 $this->skipWhitespace(0);
  1839.                 return $c;
  1840.             }
  1842.             if( $this->pos > 0 && $this->isWhitespace(-1) ){
  1843.                 return ' ';
  1844.             }
  1845.         }
  1846.     }
  1848.     //
  1849.     // A CSS selector (see selector below)
  1850.     // with less extensions e.g. the ability to extend and guard
  1851.     //
  1852.     private function parseLessSelector(){
  1853.         return $this->parseSelector(true);
  1854.     }
  1856.     //
  1857.     // A CSS Selector
  1858.     //
  1859.     //     .class > div + h1
  1860.     //     li a:hover
  1861.     //
  1862.     // Selectors are made out of one or more Elements, see above.
  1863.     //
  1864.     private function parseSelector( $isLess = false ){
  1865.         $elements = array();
  1866.         $extendList = array();
  1867.         $condition = null;
  1868.         $when = false;
  1869.         $extend = false;
  1870.         $e = null;
  1871.         $c = null;
  1872.         $index = $this->pos;
  1874.         while( ($isLess && ($extend = $this->parseExtend())) || ($isLess && ($when = $this->MatchReg('/\\Gwhen/') )) || ($e = $this->parseElement()) ){
  1875.             if( $when ){
  1876.                 $condition = $this->expect('parseConditions', 'expected condition');
  1877.             }elseif( $condition ){
  1878.                 //error("CSS guard can only be used at the end of selector");
  1879.             }elseif( $extend ){
  1880.                 $extendList = array_merge($extendList,$extend);
  1881.             }else{
  1882.                 //if( count($extendList) ){
  1883.                 //error("Extend can only be used at the end of selector");
  1884.                 //}
  1885.                 if( $this->pos < $this->input_len ){
  1886.                     $c = $this->input[ $this->pos ];
  1887.                 }
  1888.                 $elements[] = $e;
  1889.                 $e = null;
  1890.             }
  1892.             if( $c === '{' || $c === '}' || $c === ';' || $c === ',' || $c === ')') { break; }
  1893.         }
  1895.         if( $elements ){
  1896.             return $this->NewObj5('Less_Tree_Selector',array($elements, $extendList, $condition, $index, $this->env->currentFileInfo));
  1897.         }
  1898.         if( $extendList ) {
  1899.             $this->Error('Extend must be used to extend a selector, it cannot be used on its own');
  1900.         }
  1901.     }
  1903.     private function parseTag(){
  1904.         return ( $tag = $this->MatchReg('/\\G[A-Za-z][A-Za-z-]*[0-9]?/') ) ? $tag : $this->MatchChar('*');
  1905.     }
  1907.     private function parseAttribute(){
  1909.         $val = null;
  1911.         if( !$this->MatchChar('[') ){
  1912.             return;
  1913.         }
  1915.         $key = $this->parseEntitiesVariableCurly();
  1916.         if( !$key ){
  1917.             $key = $this->expect('/\\G(?:[_A-Za-z0-9-\*]*\|)?(?:[_A-Za-z0-9-]|\\\\.)+/');
  1918.         }
  1920.         $op = $this->MatchReg('/\\G[|~*$^]?=/');
  1921.         if( $op ){
  1922.             $val = $this->match( array('parseEntitiesQuoted','/\\G[0-9]+%/','/\\G[\w-]+/','parseEntitiesVariableCurly') );
  1923.         }
  1925.         $this->expectChar(']');
  1927.         return $this->NewObj3('Less_Tree_Attribute',array( $key, $op === null ? null : $op[0], $val));
  1928.     }
  1930.     //
  1931.     // The `block` rule is used by `ruleset` and `mixin.definition`.
  1932.     // It's a wrapper around the `primary` rule, with added `{}`.
  1933.     //
  1934.     private function parseBlock(){
  1935.         if( $this->MatchChar('{') ){
  1936.             $content = $this->parsePrimary();
  1937.             if( $this->MatchChar('}') ){
  1938.                 return $content;
  1939.             }
  1940.         }
  1941.     }
  1943.     private function parseBlockRuleset(){
  1944.         $block = $this->parseBlock();
  1946.         if( $block ){
  1947.             $block = $this->NewObj2('Less_Tree_Ruleset',array( null, $block));
  1948.         }
  1950.         return $block;
  1951.     }
  1953.     private function parseDetachedRuleset(){
  1954.         $blockRuleset = $this->parseBlockRuleset();
  1955.         if( $blockRuleset ){
  1956.             return $this->NewObj1('Less_Tree_DetachedRuleset',$blockRuleset);
  1957.         }
  1958.     }
  1960.     //
  1961.     // div, .class, body > p {...}
  1962.     //
  1963.     private function parseRuleset(){
  1964.         $selectors = array();
  1966.         $this->save();
  1968.         while( true ){
  1969.             $s = $this->parseLessSelector();
  1970.             if( !$s ){
  1971.                 break;
  1972.             }
  1973.             $selectors[] = $s;
  1974.             $this->parseComments();
  1976.             if( $s->condition && count($selectors) > 1 ){
  1977.                 $this->Error('Guards are only currently allowed on a single selector.');
  1978.             }
  1980.             if( !$this->MatchChar(',') ){
  1981.                 break;
  1982.             }
  1983.             if( $s->condition ){
  1984.                 $this->Error('Guards are only currently allowed on a single selector.');
  1985.             }
  1986.             $this->parseComments();
  1987.         }
  1990.         if( $selectors ){
  1991.             $rules = $this->parseBlock();
  1992.             if( is_array($rules) ){
  1993.                 $this->forget();
  1994.                 return $this->NewObj2('Less_Tree_Ruleset',array( $selectors, $rules)); //Less_Environment::$strictImports
  1995.             }
  1996.         }
  1998.         // Backtrack
  1999.         $this->furthest = $this->pos;
  2000.         $this->restore();
  2001.     }
  2003.     /**
  2004.      * Custom less.php parse function for finding simple name-value css pairs
  2005.      * ex: width:100px;
  2006.      *
  2007.      */
  2008.     private function parseNameValue(){
  2010.         $index = $this->pos;
  2011.         $this->save();
  2014.         //$match = $this->MatchReg('/\\G([a-zA-Z\-]+)\s*:\s*((?:\'")?[a-zA-Z0-9\-% \.,!]+?(?:\'")?)\s*([;}])/');
  2015.         $match = $this->MatchReg('/\\G([a-zA-Z\-]+)\s*:\s*([\'"]?[#a-zA-Z0-9\-%\.,]+?[\'"]?) *(! *important)?\s*([;}])/');
  2016.         if( $match ){
  2018.             if( $match[4] == '}' ){
  2019.                 $this->pos = $index + strlen($match[0])-1;
  2020.             }
  2022.             if( $match[3] ){
  2023.                 $match[2] .= ' !important';
  2024.             }
  2026.             return $this->NewObj4('Less_Tree_NameValue',array( $match[1], $match[2], $index, $this->env->currentFileInfo));
  2027.         }
  2029.         $this->restore();
  2030.     }
  2033.     private function parseRule( $tryAnonymous = null ){
  2035.         $merge = false;
  2036.         $startOfRule = $this->pos;
  2038.         $c = $this->input[$this->pos];
  2039.         if( $c === '.' || $c === '#' || $c === '&' ){
  2040.             return;
  2041.         }
  2043.         $this->save();
  2044.         $name = $this->MatchFuncs( array('parseVariable','parseRuleProperty'));
  2046.         if( $name ){
  2048.             $isVariable = is_string($name);
  2050.             $value = null;
  2051.             if( $isVariable ){
  2052.                 $value = $this->parseDetachedRuleset();
  2053.             }
  2055.             $important = null;
  2056.             if( !$value ){
  2058.                 // prefer to try to parse first if its a variable or we are compressing
  2059.                 // but always fallback on the other one
  2060.                 //if( !$tryAnonymous && is_string($name) && $name[0] === '@' ){
  2061.                 if( !$tryAnonymous && (Less_Parser::$options['compress'] || $isVariable) ){
  2062.                     $value = $this->MatchFuncs( array('parseValue','parseAnonymousValue'));
  2063.                 }else{
  2064.                     $value = $this->MatchFuncs( array('parseAnonymousValue','parseValue'));
  2065.                 }
  2067.                 $important = $this->parseImportant();
  2069.                 // a name returned by this.ruleProperty() is always an array of the form:
  2070.                 // [string-1, ..., string-n, ""] or [string-1, ..., string-n, "+"]
  2071.                 // where each item is a tree.Keyword or tree.Variable
  2072.                 if( !$isVariable && is_array($name) ){
  2073.                     $nm = array_pop($name);
  2074.                     if( $nm->value ){
  2075.                         $merge = $nm->value;
  2076.                     }
  2077.                 }
  2078.             }
  2081.             if( $value && $this->parseEnd() ){
  2082.                 $this->forget();
  2083.                 return $this->NewObj6('Less_Tree_Rule',array( $name, $value, $important, $merge, $startOfRule, $this->env->currentFileInfo));
  2084.             }else{
  2085.                 $this->furthest = $this->pos;
  2086.                 $this->restore();
  2087.                 if( $value && !$tryAnonymous ){
  2088.                     return $this->parseRule(true);
  2089.                 }
  2090.             }
  2091.         }else{
  2092.             $this->forget();
  2093.         }
  2094.     }
  2096.     function parseAnonymousValue(){
  2098.         if( preg_match('/\\G([^@+\/\'"*`(;{}-]*);/',$this->input, $match, 0, $this->pos) ){
  2099.             $this->pos += strlen($match[1]);
  2100.             return $this->NewObj1('Less_Tree_Anonymous',$match[1]);
  2101.         }
  2102.     }
  2104.     //
  2105.     // An @import directive
  2106.     //
  2107.     //     @import "lib";
  2108.     //
  2109.     // Depending on our environment, importing is done differently:
  2110.     // In the browser, it's an XHR request, in Node, it would be a
  2111.     // file-system operation. The function used for importing is
  2112.     // stored in `import`, which we pass to the Import constructor.
  2113.     //
  2114.     private function parseImport(){
  2116.         $this->save();
  2118.         $dir = $this->MatchReg('/\\G@import?\s+/');
  2120.         if( $dir ){
  2121.             $options = $this->parseImportOptions();
  2122.             $path = $this->MatchFuncs( array('parseEntitiesQuoted','parseEntitiesUrl'));
  2124.             if( $path ){
  2125.                 $features = $this->parseMediaFeatures();
  2126.                 if( $this->MatchChar(';') ){
  2127.                     if( $features ){
  2128.                         $features = $this->NewObj1('Less_Tree_Value',$features);
  2129.                     }
  2131.                     $this->forget();
  2132.                     return $this->NewObj5('Less_Tree_Import',array( $path, $features, $options, $this->pos, $this->env->currentFileInfo));
  2133.                 }
  2134.             }
  2135.         }
  2137.         $this->restore();
  2138.     }
  2140.     private function parseImportOptions(){
  2142.         $options = array();
  2144.         // list of options, surrounded by parens
  2145.         if( !$this->MatchChar('(') ){
  2146.             return $options;
  2147.         }
  2148.         do{
  2149.             $optionName = $this->parseImportOption();
  2150.             if( $optionName ){
  2151.                 $value = true;
  2152.                 switch( $optionName ){
  2153.                     case "css":
  2154.                         $optionName = "less";
  2155.                         $value = false;
  2156.                         break;
  2157.                     case "once":
  2158.                         $optionName = "multiple";
  2159.                         $value = false;
  2160.                         break;
  2161.                 }
  2162.                 $options[$optionName] = $value;
  2163.                 if( !$this->MatchChar(',') ){ break; }
  2164.             }
  2165.         }while( $optionName );
  2166.         $this->expectChar(')');
  2167.         return $options;
  2168.     }
  2170.     private function parseImportOption(){
  2171.         $opt = $this->MatchReg('/\\G(less|css|multiple|once|inline|reference|optional)/');
  2172.         if( $opt ){
  2173.             return $opt[1];
  2174.         }
  2175.     }
  2177.     private function parseMediaFeature() {
  2178.         $nodes = array();
  2180.         do{
  2181.             $e = $this->MatchFuncs(array('parseEntitiesKeyword','parseEntitiesVariable'));
  2182.             if( $e ){
  2183.                 $nodes[] = $e;
  2184.             } elseif ($this->MatchChar('(')) {
  2185.                 $p = $this->parseProperty();
  2186.                 $e = $this->parseValue();
  2187.                 if ($this->MatchChar(')')) {
  2188.                     if ($p && $e) {
  2189.                         $r = $this->NewObj7('Less_Tree_Rule', array( $p, $e, null, null, $this->pos, $this->env->currentFileInfo, true));
  2190.                         $nodes[] = $this->NewObj1('Less_Tree_Paren',$r);
  2191.                     } elseif ($e) {
  2192.                         $nodes[] = $this->NewObj1('Less_Tree_Paren',$e);
  2193.                     } else {
  2194.                         return null;
  2195.                     }
  2196.                 } else
  2197.                     return null;
  2198.             }
  2199.         } while ($e);
  2201.         if ($nodes) {
  2202.             return $this->NewObj1('Less_Tree_Expression',$nodes);
  2203.         }
  2204.     }
  2206.     private function parseMediaFeatures() {
  2207.         $features = array();
  2209.         do{
  2210.             $e = $this->parseMediaFeature();
  2211.             if( $e ){
  2212.                 $features[] = $e;
  2213.                 if (!$this->MatchChar(',')) break;
  2214.             }else{
  2215.                 $e = $this->parseEntitiesVariable();
  2216.                 if( $e ){
  2217.                     $features[] = $e;
  2218.                     if (!$this->MatchChar(',')) break;
  2219.                 }
  2220.             }
  2221.         } while ($e);
  2223.         return $features ? $features : null;
  2224.     }
  2226.     private function parseMedia() {
  2227.         if( $this->MatchReg('/\\G@media/') ){
  2228.             $features = $this->parseMediaFeatures();
  2229.             $rules = $this->parseBlock();
  2231.             if( is_array($rules) ){
  2232.                 return $this->NewObj4('Less_Tree_Media',array( $rules, $features, $this->pos, $this->env->currentFileInfo));
  2233.             }
  2234.         }
  2235.     }
  2238.     //
  2239.     // A CSS Directive
  2240.     //
  2241.     // @charset "utf-8";
  2242.     //
  2243.     private function parseDirective(){
  2245.         if( !$this->PeekChar('@') ){
  2246.             return;
  2247.         }
  2249.         $rules = null;
  2250.         $index = $this->pos;
  2251.         $hasBlock = true;
  2252.         $hasIdentifier = false;
  2253.         $hasExpression = false;
  2254.         $hasUnknown = false;
  2257.         $value = $this->MatchFuncs(array('parseImport','parseMedia'));
  2258.         if( $value ){
  2259.             return $value;
  2260.         }
  2262.         $this->save();
  2264.         $name = $this->MatchReg('/\\G@[a-z-]+/');
  2266.         if( !$name ) return;
  2267.         $name = $name[0];
  2270.         $nonVendorSpecificName = $name;
  2271.         $pos = strpos($name,'-', 2);
  2272.         if( $name[1] == '-' && $pos > 0 ){
  2273.             $nonVendorSpecificName = "@" . substr($name, $pos + 1);
  2274.         }
  2277.         switch( $nonVendorSpecificName ){
  2278.             /*
  2279.             case "@font-face":
  2280.             case "@viewport":
  2281.             case "@top-left":
  2282.             case "@top-left-corner":
  2283.             case "@top-center":
  2284.             case "@top-right":
  2285.             case "@top-right-corner":
  2286.             case "@bottom-left":
  2287.             case "@bottom-left-corner":
  2288.             case "@bottom-center":
  2289.             case "@bottom-right":
  2290.             case "@bottom-right-corner":
  2291.             case "@left-top":
  2292.             case "@left-middle":
  2293.             case "@left-bottom":
  2294.             case "@right-top":
  2295.             case "@right-middle":
  2296.             case "@right-bottom":
  2297.             hasBlock = true;
  2298.             break;
  2299.             */
  2300.             case "@charset":
  2301.                 $hasIdentifier = true;
  2302.                 $hasBlock = false;
  2303.                 break;
  2304.             case "@namespace":
  2305.                 $hasExpression = true;
  2306.                 $hasBlock = false;
  2307.                 break;
  2308.             case "@keyframes":
  2309.                 $hasIdentifier = true;
  2310.                 break;
  2311.             case "@host":
  2312.             case "@page":
  2313.             case "@document":
  2314.             case "@supports":
  2315.                 $hasUnknown = true;
  2316.                 break;
  2317.         }
  2319.         if( $hasIdentifier ){
  2320.             $value = $this->parseEntity();
  2321.             if( !$value ){
  2322.                 $this->error("expected " . $name . " identifier");
  2323.             }
  2324.         } else if( $hasExpression ){
  2325.             $value = $this->parseExpression();
  2326.             if( !$value ){
  2327.                 $this->error("expected " . $name. " expression");
  2328.             }
  2329.         } else if ($hasUnknown) {
  2331.             $value = $this->MatchReg('/\\G[^{;]+/');
  2332.             if( $value ){
  2333.                 $value = $this->NewObj1('Less_Tree_Anonymous',trim($value[0]));
  2334.             }
  2335.         }
  2337.         if( $hasBlock ){
  2338.             $rules = $this->parseBlockRuleset();
  2339.         }
  2341.         if( $rules || (!$hasBlock && $value && $this->MatchChar(';'))) {
  2342.             $this->forget();
  2343.             return $this->NewObj5('Less_Tree_Directive',array($name, $value, $rules, $index, $this->env->currentFileInfo));
  2344.         }
  2346.         $this->restore();
  2347.     }
  2350.     //
  2351.     // A Value is a comma-delimited list of Expressions
  2352.     //
  2353.     //     font-family: Baskerville, Georgia, serif;
  2354.     //
  2355.     // In a Rule, a Value represents everything after the `:`,
  2356.     // and before the `;`.
  2357.     //
  2358.     private function parseValue(){
  2359.         $expressions = array();
  2361.         do{
  2362.             $e = $this->parseExpression();
  2363.             if( $e ){
  2364.                 $expressions[] = $e;
  2365.                 if (! $this->MatchChar(',')) {
  2366.                     break;
  2367.                 }
  2368.             }
  2369.         }while($e);
  2371.         if( $expressions ){
  2372.             return $this->NewObj1('Less_Tree_Value',$expressions);
  2373.         }
  2374.     }
  2376.     private function parseImportant (){
  2377.         if( $this->PeekChar('!') && $this->MatchReg('/\\G! *important/') ){
  2378.             return ' !important';
  2379.         }
  2380.     }
  2382.     private function parseSub (){
  2384.         if( $this->MatchChar('(') ){
  2385.             $a = $this->parseAddition();
  2386.             if( $a ){
  2387.                 $this->expectChar(')');
  2388.                 return $this->NewObj2('Less_Tree_Expression',array( array($a), true) ); //instead of $e->parens = true so the value is cached
  2389.             }
  2390.         }
  2391.     }
  2394.     /**
  2395.      * Parses multiplication operation
  2396.      *
  2397.      * @return Less_Tree_Operation|null
  2398.      */
  2399.     function parseMultiplication(){
  2401.         $return = $m = $this->parseOperand();
  2402.         if( $return ){
  2403.             while( true ){
  2405.                 $isSpaced = $this->isWhitespace( -1 );
  2407.                 if( $this->PeekReg('/\\G\/[*\/]/') ){
  2408.                     break;
  2409.                 }
  2411.                 $op = $this->MatchChar('/');
  2412.                 if( !$op ){
  2413.                     $op = $this->MatchChar('*');
  2414.                     if( !$op ){
  2415.                         break;
  2416.                     }
  2417.                 }
  2419.                 $a = $this->parseOperand();
  2421.                 if(!$a) { break; }
  2423.                 $m->parensInOp = true;
  2424.                 $a->parensInOp = true;
  2425.                 $return = $this->NewObj3('Less_Tree_Operation',array( $op, array( $return, $a ), $isSpaced) );
  2426.             }
  2427.         }
  2428.         return $return;
  2430.     }
  2433.     /**
  2434.      * Parses an addition operation
  2435.      *
  2436.      * @return Less_Tree_Operation|null
  2437.      */
  2438.     private function parseAddition (){
  2440.         $return = $m = $this->parseMultiplication();
  2441.         if( $return ){
  2442.             while( true ){
  2444.                 $isSpaced = $this->isWhitespace( -1 );
  2446.                 $op = $this->MatchReg('/\\G[-+]\s+/');
  2447.                 if( $op ){
  2448.                     $op = $op[0];
  2449.                 }else{
  2450.                     if( !$isSpaced ){
  2451.                         $op = $this->match(array('#+','#-'));
  2452.                     }
  2453.                     if( !$op ){
  2454.                         break;
  2455.                     }
  2456.                 }
  2458.                 $a = $this->parseMultiplication();
  2459.                 if( !$a ){
  2460.                     break;
  2461.                 }
  2463.                 $m->parensInOp = true;
  2464.                 $a->parensInOp = true;
  2465.                 $return = $this->NewObj3('Less_Tree_Operation',array($op, array($return, $a), $isSpaced));
  2466.             }
  2467.         }
  2469.         return $return;
  2470.     }
  2473.     /**
  2474.      * Parses the conditions
  2475.      *
  2476.      * @return Less_Tree_Condition|null
  2477.      */
  2478.     private function parseConditions() {
  2479.         $index = $this->pos;
  2480.         $return = $a = $this->parseCondition();
  2481.         if( $a ){
  2482.             while( true ){
  2483.                 if( !$this->PeekReg('/\\G,\s*(not\s*)?\(/') ||  !$this->MatchChar(',') ){
  2484.                     break;
  2485.                 }
  2486.                 $b = $this->parseCondition();
  2487.                 if( !$b ){
  2488.                     break;
  2489.                 }
  2491.                 $return = $this->NewObj4('Less_Tree_Condition',array('or', $return, $b, $index));
  2492.             }
  2493.             return $return;
  2494.         }
  2495.     }
  2497.     private function parseCondition() {
  2498.         $index = $this->pos;
  2499.         $negate = false;
  2500.         $c = null;
  2502.         if ($this->MatchReg('/\\Gnot/')) $negate = true;
  2503.         $this->expectChar('(');
  2504.         $a = $this->MatchFuncs(array('parseAddition','parseEntitiesKeyword','parseEntitiesQuoted'));
  2506.         if( $a ){
  2507.             $op = $this->MatchReg('/\\G(?:>=|<=|=<|[<=>])/');
  2508.             if( $op ){
  2509.                 $b = $this->MatchFuncs(array('parseAddition','parseEntitiesKeyword','parseEntitiesQuoted'));
  2510.                 if( $b ){
  2511.                     $c = $this->NewObj5('Less_Tree_Condition',array($op[0], $a, $b, $index, $negate));
  2512.                 } else {
  2513.                     $this->Error('Unexpected expression');
  2514.                 }
  2515.             } else {
  2516.                 $k = $this->NewObj1('Less_Tree_Keyword','true');
  2517.                 $c = $this->NewObj5('Less_Tree_Condition',array('=', $a, $k, $index, $negate));
  2518.             }
  2519.             $this->expectChar(')');
  2520.             return $this->MatchReg('/\\Gand/') ? $this->NewObj3('Less_Tree_Condition',array('and', $c, $this->parseCondition())) : $c;
  2521.         }
  2522.     }
  2524.     /**
  2525.      * An operand is anything that can be part of an operation,
  2526.      * such as a Color, or a Variable
  2527.      *
  2528.      */
  2529.     private function parseOperand (){
  2531.         $negate = false;
  2532.         $offset = $this->pos+1;
  2533.         if( $offset >= $this->input_len ){
  2534.             return;
  2535.         }
  2536.         $char = $this->input[$offset];
  2537.         if( $char === '@' || $char === '(' ){
  2538.             $negate = $this->MatchChar('-');
  2539.         }
  2541.         $o = $this->MatchFuncs(array('parseSub','parseEntitiesDimension','parseEntitiesColor','parseEntitiesVariable','parseEntitiesCall'));
  2543.         if( $negate ){
  2544.             $o->parensInOp = true;
  2545.             $o = $this->NewObj1('Less_Tree_Negative',$o);
  2546.         }
  2548.         return $o;
  2549.     }
  2552.     /**
  2553.      * Expressions either represent mathematical operations,
  2554.      * or white-space delimited Entities.
  2555.      *
  2556.      *     1px solid black
  2557.      *     @var * 2
  2558.      *
  2559.      * @return Less_Tree_Expression|null
  2560.      */
  2561.     private function parseExpression (){
  2562.         $entities = array();
  2564.         do{
  2565.             $e = $this->MatchFuncs(array('parseAddition','parseEntity'));
  2566.             if( $e ){
  2567.                 $entities[] = $e;
  2568.                 // operations do not allow keyword "/" dimension (e.g. small/20px) so we support that here
  2569.                 if( !$this->PeekReg('/\\G\/[\/*]/') ){
  2570.                     $delim = $this->MatchChar('/');
  2571.                     if( $delim ){
  2572.                         $entities[] = $this->NewObj1('Less_Tree_Anonymous',$delim);
  2573.                     }
  2574.                 }
  2575.             }
  2576.         }while($e);
  2578.         if( $entities ){
  2579.             return $this->NewObj1('Less_Tree_Expression',$entities);
  2580.         }
  2581.     }
  2584.     /**
  2585.      * Parse a property
  2586.      * eg: 'min-width', 'orientation', etc
  2587.      *
  2588.      * @return string
  2589.      */
  2590.     private function parseProperty (){
  2591.         $name = $this->MatchReg('/\\G(\*?-?[_a-zA-Z0-9-]+)\s*:/');
  2592.         if( $name ){
  2593.             return $name[1];
  2594.         }
  2595.     }
  2598.     /**
  2599.      * Parse a rule property
  2600.      * eg: 'color', 'width', 'height', etc
  2601.      *
  2602.      * @return string
  2603.      */
  2604.     private function parseRuleProperty(){
  2605.         $offset = $this->pos;
  2606.         $name = array();
  2607.         $index = array();
  2608.         $length = 0;
  2611.         $this->rulePropertyMatch('/\\G(\*?)/', $offset, $length, $index, $name );
  2612.         while( $this->rulePropertyMatch('/\\G((?:[\w-]+)|(?:@\{[\w-]+\}))/', $offset, $length, $index, $name )); // !
  2614.         if( (count($name) > 1) && $this->rulePropertyMatch('/\\G\s*((?:\+_|\+)?)\s*:/', $offset, $length, $index, $name) ){
  2615.             // at last, we have the complete match now. move forward,
  2616.             // convert name particles to tree objects and return:
  2617.             $this->skipWhitespace($length);
  2619.             if( $name[0] === '' ){
  2620.                 array_shift($name);
  2621.                 array_shift($index);
  2622.             }
  2623.             foreach($name as $k => $s ){
  2624.                 if( !$s || $s[0] !== '@' ){
  2625.                     $name[$k] = $this->NewObj1('Less_Tree_Keyword',$s);
  2626.                 }else{
  2627.                     $name[$k] = $this->NewObj3('Less_Tree_Variable',array('@' . substr($s,2,-1), $index[$k], $this->env->currentFileInfo));
  2628.                 }
  2629.             }
  2630.             return $name;
  2631.         }
  2634.     }
  2636.     private function rulePropertyMatch( $re, &$offset, &$length,  &$index, &$name ){
  2637.         preg_match($re, $this->input, $a, 0, $offset);
  2638.         if( $a ){
  2639.             $index[] = $this->pos + $length;
  2640.             $length += strlen($a[0]);
  2641.             $offset += strlen($a[0]);
  2642.             $name[] = $a[1];
  2643.             return true;
  2644.         }
  2645.     }
  2647.     public static function serializeVars( $vars ){
  2648.         $s = '';
  2650.         foreach($vars as $name => $value){
  2651.             $s .= (($name[0] === '@') ? '' : '@') . $name .': '. $value . ((substr($value,-1) === ';') ? '' : ';');
  2652.         }
  2654.         return $s;
  2655.     }
  2658.     /**
  2659.      * Some versions of php have trouble with method_exists($a,$b) if $a is not an object
  2660.      *
  2661.      * @param string $b
  2662.      */
  2663.     public static function is_method($a,$b){
  2664.         return is_object($a) && method_exists($a,$b);
  2665.     }
  2668.     /**
  2669.      * Round numbers similarly to javascript
  2670.      * eg: 1.499999 to 1 instead of 2
  2671.      *
  2672.      */
  2673.     public static function round($i, $precision = 0){
  2675.         $precision = pow(10,$precision);
  2676.         $i = $i*$precision;
  2678.         $ceil = ceil($i);
  2679.         $floor = floor($i);
  2680.         if( ($ceil - $i) <= ($i - $floor) ){
  2681.             return $ceil/$precision;
  2682.         }else{
  2683.             return $floor/$precision;
  2684.         }
  2685.     }
  2688.     /**
  2689.      * Create Less_Tree_* objects and optionally generate a cache string
  2690.      *
  2691.      * @return mixed
  2692.      */
  2693.     public function NewObj0($class){
  2694.         $obj = new $class();
  2695.         if( $this->CacheEnabled() ){
  2696.             $obj->cache_string = ' new '.$class.'()';
  2697.         }
  2698.         return $obj;
  2699.     }
  2701.     public function NewObj1($class, $arg){
  2702.         $obj = new $class( $arg );
  2703.         if( $this->CacheEnabled() ){
  2704.             $obj->cache_string = ' new '.$class.'('.Less_Parser::ArgString($arg).')';
  2705.         }
  2706.         return $obj;
  2707.     }
  2709.     public function NewObj2($class, $args){
  2710.         $obj = new $class( $args[0], $args[1] );
  2711.         if( $this->CacheEnabled() ){
  2712.             $this->ObjCache( $obj, $class, $args);
  2713.         }
  2714.         return $obj;
  2715.     }
  2717.     public function NewObj3($class, $args){
  2718.         $obj = new $class( $args[0], $args[1], $args[2] );
  2719.         if( $this->CacheEnabled() ){
  2720.             $this->ObjCache( $obj, $class, $args);
  2721.         }
  2722.         return $obj;
  2723.     }
  2725.     public function NewObj4($class, $args){
  2726.         $obj = new $class( $args[0], $args[1], $args[2], $args[3] );
  2727.         if( $this->CacheEnabled() ){
  2728.             $this->ObjCache( $obj, $class, $args);
  2729.         }
  2730.         return $obj;
  2731.     }
  2733.     public function NewObj5($class, $args){
  2734.         $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4] );
  2735.         if( $this->CacheEnabled() ){
  2736.             $this->ObjCache( $obj, $class, $args);
  2737.         }
  2738.         return $obj;
  2739.     }
  2741.     public function NewObj6($class, $args){
  2742.         $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4], $args[5] );
  2743.         if( $this->CacheEnabled() ){
  2744.             $this->ObjCache( $obj, $class, $args);
  2745.         }
  2746.         return $obj;
  2747.     }
  2749.     public function NewObj7($class, $args){
  2750.         $obj = new $class( $args[0], $args[1], $args[2], $args[3], $args[4], $args[5], $args[6] );
  2751.         if( $this->CacheEnabled() ){
  2752.             $this->ObjCache( $obj, $class, $args);
  2753.         }
  2754.         return $obj;
  2755.     }
  2757.     //caching
  2758.     public function ObjCache($obj, $class, $args=array()){
  2759.         $obj->cache_string = ' new '.$class.'('. self::ArgCache($args).')';
  2760.     }
  2762.     public function ArgCache($args){
  2763.         return implode(',',array_map( array('Less_Parser','ArgString'),$args));
  2764.     }
  2767.     /**
  2768.      * Convert an argument to a string for use in the parser cache
  2769.      *
  2770.      * @return string
  2771.      */
  2772.     public static function ArgString($arg){
  2774.         $type = gettype($arg);
  2776.         if( $type === 'object'){
  2777.             $string = $arg->cache_string;
  2778.             unset($arg->cache_string);
  2779.             return $string;
  2781.         }elseif( $type === 'array' ){
  2782.             $string = ' Array(';
  2783.             foreach($arg as $k => $a){
  2784.                 $string .= var_export($k,true).' => '.self::ArgString($a).',';
  2785.             }
  2786.             return $string . ')';
  2787.         }
  2789.         return var_export($arg,true);
  2790.     }
  2792.     public function Error($msg){
  2793.         throw new Less_Exception_Parser($msg, null, $this->furthest, $this->env->currentFileInfo);
  2794.     }
  2796.     public static function WinPath($path){
  2797.         return str_replace('\\', '/', $path);
  2798.     }
  2800.     public static function AbsPath($path, $winPath = false){
  2801.         if (strpos($path, '//') !== false && preg_match('_^(https?:)?//\\w+(\\.\\w+)+/\\w+_i', $path)) {
  2802.             return $winPath ? '' : false;
  2803.         } else {
  2804.             $path = realpath($path);
  2805.             if ($winPath) {
  2806.                 $path = self::WinPath($path);
  2807.             }
  2808.             return $path;
  2809.         }
  2810.     }
  2812.     public function CacheEnabled(){
  2813.         return (Less_Parser::$options['cache_method'] && (Less_Cache::$cache_dir || (Less_Parser::$options['cache_method'] == 'callback')));
  2814.     }
  2816. }