engine.php

<?php
/*
\Bitrix\Main\Loader::includeModule('iblock');
 
$arFields = array(
    "IBLOCK_ID" => 422,
    "NAME" => "Product name",
    "CODE" => "main code",
    "IBLOCK_SECTION_ID" => 12744,
    "PROPERTY_VALUES" => array(
        "CML2_ARTICLE" => "XX-SM6-XXXXXXXXX",
    ),
);
$element = new \Bitrix\Iblock\Template\Entity\Element(0);
$element->setFields($arFields);
echo "<pre>";//print_r($element);
$arSkuCollection = array();
for ($i = 0; $i < 5; $i++)
{
    $arSkuCollection[$i] = array(
        "IBLOCK_ID" => 423,
        "NAME" => null,
        "CODE" => "code($i)",
        "PROPERTY_VALUES" => array(
            "CML2_LINK" => $element,
            "1377" => "0x0555555".$i,
            "1875" => 1045,
        ),
    );
    $sku = new \Bitrix\Iblock\Template\Entity\Element(0);
    $sku->setFields($arSkuCollection[$i]);//print_r($sku);
    $arSkuCollection[$i]["NAME"] = \Bitrix\Iblock\Template\Engine::process(
        $sku
        //,'{=this.property.cml2_link.name}:  {=this.property.cml2_link.property.CML2_ARTICUL}, {=this.property.cml2_bar_code}'
        //,'Q{=this.code}Q'
        //,'Q{=this.property}Q'
        ,'Q{=this.property.1377}Q{=this.property.1875}Q'
        //,'Q{=this.property.CML2_LINK}Q'
        //,'Q{=this.property.CML2_LINK.name}Q'
        //,'Q{=this.property.CML2_LINK.code}Q'
        //,'Q{=this.property.CML2_LINK.property.CML2_ARTICLE}Q'
        //,'Q{=this.property.CML2_LINK.parent.property.str}Q'
        //,'Q{=this.catalog.price.base}Q'
        //,'Q{=this.catalog.weight}Q'
        //,'Q{=this.catalog.measure}Q'
        //,'Q{=this.catalog.store.1.name}Q'
        //,'Q{=catalog.store}Q'
    );
}
echo "<pre>",htmlspecialcharsEx(print_r($arSkuCollection,1)),"</pre>";
*/
namespace Bitrix\Iblock\Template;
class Engine
{
    public static function process(Entity\Base $entity, $template)
    {
        $rootNode = self::parseTemplateTree($template, new NodeRoot);
        return $rootNode->process($entity);
    }
 
    protected static function parseTemplateTree($template, NodeRoot $parent)
    {
        list($template, $modifiers) = Helper::splitTemplate($template);
        if ($modifiers != "")
            $parent->setModifiers($modifiers);
 
        $parsedTemplate = preg_split('/({=|})/',  $template, -1, PREG_SPLIT_DELIM_CAPTURE);
        while (($token = array_shift($parsedTemplate)) !== null)
        {
            $node = null;
 
            if ($token === "{=")
            {
                $node = self::parseFormula($parsedTemplate);
            }
            elseif ($token !== "")
            {
                $node = new NodeText($token);
            }
 
            if ($node)
                $parent->addChild($node);
        }
        return $parent;
    }
 
    protected static function parseFormula(array &$parsedTemplate)
    {
        $node = null;
        if (($token = array_shift($parsedTemplate)) !== null)
        {
            if (preg_match("/^([a-zA-Z0-9_]+\\.[a-zA-Z0-9_.]+)\\s*\$/", $token, $match))
            {
                $node = new NodeEntityField($match[1]);
            }
            elseif (preg_match("/^([a-zA-Z0-9_]+)(.*)\$/", $token, $match))
            {
                $node = new NodeFunction($match[1]);
                self::parseFunctionArguments($match[2], $parsedTemplate, $node);
            }
        }
        //Eat up to the formula end
        while (($token = array_shift($parsedTemplate)) !== null)
        {
            if ($token === "}")
                break;
        }
        return $node;
    }
 
    protected static function parseFunctionArguments($token, array &$parsedTemplate, NodeFunction $function)
    {
        $token = ltrim($token, " \t\n\r");
 
        if ($token !== "")
            self::explodeFunctionArgument($token, $function);
 
        while (($token = array_shift($parsedTemplate)) !== null)
        {
            if ($token === "}")
            {
                array_unshift($parsedTemplate, $token);
                break;
            }
            elseif ($token === "{=")
            {
                $node = self::parseFormula($parsedTemplate);
                if ($node)
                    $function->addParameter($node);
            }
            elseif ($token !== "")
            {
                self::explodeFunctionArgument($token, $function);
            }
        }
    }
 
    protected static function explodeFunctionArgument($token, NodeFunction $function)
    {
        if (preg_match_all("/
            (
                [a-zA-Z0-9_]+\\.[a-zA-Z0-9_.]+
                |[0-9]+
                |\"[^\"]*\"
            )
            /x", $token, $wordList)
        )
        {
            foreach ($wordList[0] as $word)
            {
                if ($word !== "")
                {
                    if (preg_match("/^([a-zA-Z0-9_]+\\.[a-zA-Z0-9_.]+)\\s*\$/", $word, $match))
                    {
                        $node = new NodeEntityField($match[1]);
                    }
                    else
                    {
                        $node = new NodeText(trim($word, '"'));
                    }
                    $function->addParameter($node);
                }
            }
        }
    }
}
 
abstract class NodeBase
{
    abstract public function process(Entity\Base $entity);
}
 
class NodeRoot extends NodeBase
{
    protected $children = array();
    protected $modifiers = array();
 
    public function addChild(NodeBase $child)
    {
        $this->children[] = $child;
    }
 
    public function setModifiers($modifiers)
    {
        $this->modifiers = array();
        foreach(Helper::splitModifiers($modifiers) as $mod)
        {
            if ($mod == "l")
                $modifierFunction = Functions\Fabric::createInstance("lower");
            else
                $modifierFunction = Functions\Fabric::createInstance("translit", array(
                    "replace_space" => mb_substr($mod, 1),
                ));
            $this->modifiers[] = $modifierFunction;
        }
    }
 
    public function process(Entity\Base $entity)
    {
        $content = "";
        foreach ($this->children as $child)
        {
            $childContent = $child->process($entity);
            if (is_array($childContent))
                $content .= implode(" ", $childContent);
            else
                $content .= $childContent;
        }
        foreach ($this->modifiers as $modifier)
        {
            $node = new NodeText($content);
            $arguments = $modifier->onPrepareParameters($entity, array($node));
            $content = $modifier->calculate($arguments);
        }
        return $content;
    }
}
 
class NodeText extends NodeBase
{
    protected $content = "";
 
    function __construct($content = "")
    {
        $this->content = $content;
    }
 
    public function process(Entity\Base $entity)
    {
        return $this->content;
    }
}
 
class NodeEntityField extends NodeBase
{
    protected $entityField = "";
 
    function __construct($entityField = "")
    {
        $this->entityField = mb_strtolower($entityField);
    }
 
    public function process(Entity\Base $entity)
    {
        $entityObject = $entity;
        $pathToField = explode(".", $this->entityField);
        for ($i = 0, $c = count($pathToField)-1; $i < $c; $i++)
        {
            $entityObject = $entityObject->resolve($pathToField[$i]);
        }
        if ($entityObject)
            return $entityObject->getField($pathToField[$c]);
        else
            return "";
    }
}
 
class NodeFunction extends NodeBase
{
    protected $functionName = "";
    protected $parameters = array();
 
    public function __construct($functionName = "")
    {
        $this->functionName = mb_strtolower($functionName);
    }
 
    public function addParameter(NodeBase $parameter)
    {
        $this->parameters[] = $parameter;
    }
 
    public function process(Entity\Base $entity)
    {
        $functionObject = Functions\Fabric::createInstance($this->functionName);
        if ($functionObject instanceof Functions\FunctionBase)
        {
            $arguments = $functionObject->onPrepareParameters($entity, $this->parameters);
            return $functionObject->calculate($arguments);
        }
        else
        {
            return "";
        }
    }
}