implemented arguments of current table

src/Frontend/AbstractScanner.php

     {
         return $this->source->peekChar();
     }
+
+    /**
+     * Return the next chars from source after without moving forward
+     *
+     * @param int $len
+     *
+     * @return string
+     */
+    public function peekRange(int $len): string
+    {
+        return $this->source->peekRange($len);
+    }
 }

src/Intermediate/CodeImpl/CodeNodeImpl.php

     private $type;
 
     /**
-     * Is skipped node
-     *
-     * @var bool
-     */
-    private $is_skipped;
-    
-    /**
      * Code node parent node
      *
      * @var CodeNodeInterface
      *
      * @param string $type
      */
-    public function __construct(string $type, bool $is_skipped = false)
+    public function __construct(string $type)
     {
         $this->type = $type;
-        $this->is_skipped = $is_skipped;
     }
     
     /**
     }
 
     /**
-     * Check if node is skipped
-     *
-     * @return bool
-     */
-    public function isSkipped(): bool
-    {
-        return $this->is_skipped;
-    }
-    
-    /**
      * Get node parent node
      *
      * @return CodeNodeInterface
      */
     public function addChild(CodeNodeInterface $node = null)
     {
-        if (is_null($node) || $node->isSkipped()) {
-            return null;
-        }
-
         if (!is_null($node)) {
             $this->children[] = $node;
             $node->setParent($this);

src/Intermediate/CodeImpl/CodeNodeTypeImpl.php

 {
     // root code node for all languages
     const DSL = "dsl";
-    // skip node for all languages
-    const SKIP = "skip";
 
     // general functions
     const SUM = "sum";

src/Intermediate/CodeFactory.php

      * Create and return a node implementation
      *
      * @param string $type
-     * @param string $is_skipped
      */
-    public static function createCodeNode($type, bool $is_skipped = false): CodeNodeImpl
+    public static function createCodeNode($type): CodeNodeImpl
     {
-        return new CodeNodeImpl($type, $is_skipped);
+        return new CodeNodeImpl($type);
     }
 }

src/Intermediate/CodeNodeInterface.php

 {
     public function getType(): string;
 
-    public function isSkipped(): bool;
-    
     public function setParent(CodeNodeInterface $node);
     
     public function getParent(): CodeNodeInterface;

src/Language/ColumnFormula/Backend/Interpreters/ExpressionInterpreter.php

 use Language\Intermediate\CodeNodeInterface;
 use Language\Intermediate\CodeImpl\CodeKeyImpl;
 use Language\Intermediate\CodeImpl\CodeNodeTypeImpl;
-use Language\Intermediate\ColumnFormula\Frontend\ColumnFormulaTokenType;
+use Language\Language\ColumnFormula\Frontend\ColumnFormulaTokenType;
 use Language\Language\ColumnFormula\Backend\ColumnFormulaInterpreter;
 use Language\Message\MessageType;
 use Language\Message\Message;
             $children = $node->getChildren();
             $node1 = $children[0];
             $node2 = $children[1];
+            self::$sql_select_statement .= '(';
             $this->execute($node1);
             if ($nodeType == CodeNodeTypeImpl::ADD) {
                 self::$sql_select_statement .= '+';
+            } elseif ($nodeType == CodeNodeTypeImpl::SUBTRACT) {
+                self::$sql_select_statement .= '-';
+            } elseif ($nodeType == CodeNodeTypeImpl::MULTIPLY) {
+                self::$sql_select_statement .= '*';
+            } elseif ($nodeType == CodeNodeTypeImpl::DIVIDE) {
+                self::$sql_select_statement .= '/';
             }
             $this->execute($node2);
+            self::$sql_select_statement .= ')';
         } elseif ($nodeType == CodeNodeTypeImpl::NUMBER) {
             self::$sql_select_statement .= $node->getAttribute(CodeKeyImpl::VALUE);
+        } elseif ($nodeType == ColumnFormulaTokenType::CHIP) {
+            $value_string = $node->getAttribute(CodeKeyImpl::VALUE);
+            $values = explode(" ", $value_string);
+            $valuesMap = [];
+            if (!empty($values)) {
+                foreach ($values as $item) {
+                    $pair = explode("=", $item);
+                    $valuesMap[$pair[0]] = intval(str_replace('"', '', $pair[1]));
+                }
+            }
+            if (!array_key_exists("target_object_id", $valuesMap)) {
+                self::$sql_select_statement .= "o.attr_{$valuesMap['field_id']}_";
+            }
         }
     }
 }

src/Language/ColumnFormula/Frontend/Parsers/ExpressionParser.php

     private function parseExpression(Token $token = null)
     {
         $rootNode = $this->parseSimpleExpression($token);
-        $token = $this->currentToken();
         return $rootNode;
     }
 
     private function parseSimpleExpression(Token $token = null)
     {
         $rootNode = $this->parseTerm($token);
-        $this->skipNodes();
         $token = $this->currentToken();
-        $tokenText = $token->getText();
-        while (ColumnFormulaTokenType::isAdditive($tokenText)) {
-            if ($tokenText == ColumnFormulaTokenType::ADD) {
+        $tokenType = $token->getType();
+        while (ColumnFormulaTokenType::isAdditive($tokenType)) {
+            if ($tokenType == ColumnFormulaTokenType::ADD) {
                 $nodeType = CodeNodeTypeImpl::ADD;
-            } elseif ($tokenText == ColumnFormulaTokenType::SUBTRACT) {
+            } elseif ($tokenType == ColumnFormulaTokenType::SUBTRACT) {
                 $nodeType = CodeNodeTypeImpl::SUBTRACT;
             }
             $opNode = CodeFactory::createCodeNode($nodeType);
             $opNode->addChild($this->parseTerm($token));
             $rootNode = $opNode;
             $token = $this->currentToken();
-            $tokenText = $token->getText();
+            $tokenType = $token->getType();
         }
         return $rootNode;
     }
 
     private function parseTerm(Token $token = null)
     {
-        $node = $this->parseFactor($token);
-        if (!is_null($node) && $node->isSkipped()) {
-            $this->skipNodes();
+        $rootNode = $this->parseFactor($token);
+        $token = $this->currentToken();
+        $tokenType = $token->getType();
+        while (ColumnFormulaTokenType::isMultiplicative($tokenType)) {
+            if ($tokenType == ColumnFormulaTokenType::MULTIPLY) {
+                $nodeType = CodeNodeTypeImpl::MULTIPLY;
+            } elseif ($tokenType == ColumnFormulaTokenType::DIVIDE) {
+                $nodeType = CodeNodeTypeImpl::DIVIDE;
+            }
+            $opNode = CodeFactory::createCodeNode($nodeType);
+            $opNode->addChild($rootNode);
+            $token = $this->nextToken();
+            $opNode->addChild($this->parseTerm($token));
+            $rootNode = $opNode;
             $token = $this->currentToken();
-            $node = $this->parseFactor($token);
-        }
-        $tokenText = $token->getText();
-        while (ColumnFormulaTokenType::isMultiplicative($tokenText)) {
-            //
+            $tokenType = $token->getType();
         }
-        return $node;
+        return $rootNode;
     }
 
     private function parseFactor(Token $token = null)
     {
         $tokenType = $token->getType();
         switch ($tokenType) {
-            case ColumnFormulaTokenType::SKIP:
-                $rootNode = CodeFactory::createCodeNode(CodeNodeTypeImpl::SKIP, true);
-                $this->nextToken();
-                return $rootNode;
             case ColumnFormulaTokenType::NUMBER:
                 $rootNode = CodeFactory::createCodeNode(CodeNodeTypeImpl::NUMBER);
                 $rootNode->setAttribute(CodeKeyImpl::VALUE, $token->getValue());
                 $this->nextToken();
                 return $rootNode;
+            case ColumnFormulaTokenType::CHIP:
+                $rootNode = CodeFactory::createCodeNode(ColumnFormulaTokenType::CHIP);
+                $rootNode->setAttribute(CodeKeyImpl::VALUE, $token->getValue());
+                $this->nextToken();
+                return $rootNode;
+            case ColumnFormulaTokenType::LEFT_PAREN:
+                $token = $this->nextToken();
+                $rootNode = $this->parseExpression($token);
+                $token = $this->currentToken();
+                if ($token->getType() == ColumnFormulaTokenType::RIGHT_PAREN) {
+                    $token = $this->nextToken();
+                }
+                return $rootNode;
             default:
                 return null;
         }