From 78c82f4b6e8ff8fd381f52acf16326db970e2734 Mon Sep 17 00:00:00 2001
From: Vladislav Pavlov <super.vladpavlov@yandex.ru>
Date: Sat, 20 May 2023 22:02:35 +0300
Subject: [PATCH] =?UTF-8?q?=D1=83=D0=BA=D0=B0=D0=B7=D0=B0=D1=82=D0=B5?=
 =?UTF-8?q?=D0=BB=D0=B8=20=D0=B2=20=D0=BA=D0=BB=D0=B0=D1=81=D1=81=D0=B0?=
 =?UTF-8?q?=D1=85=20=D1=81=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20=D1=83=D0=BC?=
 =?UTF-8?q?=D0=BD=D1=8B=D0=BC=D0=B8?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 query_language/classes.cpp     |  40 ++++++-------
 query_language/classes.h       |  28 ++++-----
 query_language/interpreter.cpp |   8 +--
 query_language/interpreter.h   |  16 +++---
 query_language/main.cpp        |  25 ++------
 query_language/parcer.cpp      | 102 ++++++++++++++-------------------
 query_language/parcer.h        |  28 ++++-----
 7 files changed, 103 insertions(+), 144 deletions(-)

diff --git a/query_language/classes.cpp b/query_language/classes.cpp
index 1ac68dd..530a325 100644
--- a/query_language/classes.cpp
+++ b/query_language/classes.cpp
@@ -12,46 +12,38 @@ void literal::accept(expr_visitor* visitor) {
     visitor->visit(this);
 }
 
-binary::binary(expr* l, token tok, expr* r) : left(l), op(tok), right(r) {};
-binary::~binary() {
-    delete left;
-    delete right;
-}
+binary::binary(std::unique_ptr<expr> l, token tok, std::unique_ptr<expr> r) :
+ left(std::move(l)), op(tok), right(std::move(r)) {};
+binary::~binary() {}
 void binary::accept(expr_visitor* visitor){
     visitor->visit(this);
 }
 
-unary::unary(expr* e, token t) : ex(e), op(t) {};
-unary::~unary() {
-    delete ex;
-}
+unary::unary(std::unique_ptr<expr> expr_, token t) : ex(std::move(expr_)), op(t) {};
+unary::~unary() {}
+
 void unary::accept(expr_visitor* visitor){
     visitor->visit(this);
 }
 
-logical_expr::logical_expr(expr* l, token t, expr* r) : left(l), oper(t), right(r) {};
-logical_expr::~logical_expr() {
-    delete left;
-    delete right;
-}
+logical_expr::logical_expr(std::unique_ptr<expr> left_, token t, std::unique_ptr<expr> right_) :
+left(std::move(left_)), oper(t), right(std::move(right_)) {};
+logical_expr::~logical_expr() {}
+
 void logical_expr::accept(expr_visitor* visitor) {
     visitor->visit(this);
 }
 
-func_in::func_in(expr* l, expr* r) : left(l), right(r) {};
-func_in::~func_in() {
-    delete left;
-    delete right;
-}
+func_in::func_in(std::unique_ptr<expr> left_, std::unique_ptr<expr> right_) :
+ left(std::move(left_)), right(std::move(right_)) {};
+func_in::~func_in() {}
+
 void func_in::accept(expr_visitor* visitor) {
     visitor->visit(this);
 }
 
-grouping::grouping(expr* e) : expression(e) {};
-
-grouping::~grouping() {
-    delete expression;
-}
+grouping::grouping(std::unique_ptr<expr> expr_) : expression(std::move(expr_)) {};
+grouping::~grouping() {};
 
 void grouping::accept(expr_visitor* visitor){
     visitor->visit(this);
diff --git a/query_language/classes.h b/query_language/classes.h
index f3d7f64..cf915c5 100644
--- a/query_language/classes.h
+++ b/query_language/classes.h
@@ -8,7 +8,7 @@ class logical_expr;
 class func_in; 
 class literal;
 
-//enum value_type{BOOL, JSON, DOUBLE, EMPTY};
+
 
 struct value{
     token_type val_type;
@@ -59,11 +59,11 @@ public:
 
 class binary : public expr {
 public:
-    expr* left;
+    std::unique_ptr<expr> left;
     token op;
-    expr* right;
+    std::unique_ptr<expr> right;
 
-    binary(expr* l, token tok, expr* r);
+    binary(std::unique_ptr<expr> l, token tok, std::unique_ptr<expr> r);
     virtual ~binary();
     void accept(expr_visitor* visitor);
 };
@@ -72,10 +72,10 @@ public:
 
 class func_in : public expr {
 public:
-    expr* left;
-    expr* right;
+    std::unique_ptr<expr> left;
+    std::unique_ptr<expr> right;
 
-    func_in(expr* l, expr* r);
+    func_in(std::unique_ptr<expr> l, std::unique_ptr<expr> r);
     virtual ~func_in();
     void accept(expr_visitor* visitor);
 };
@@ -84,10 +84,10 @@ public:
 
 class unary : public expr {
 public:
-    expr* ex;
+    std::unique_ptr<expr> ex;
     token op;
 
-    unary(expr* e, token t);
+    unary(std::unique_ptr<expr> e, token t);
     virtual ~unary();
     void accept(expr_visitor* visitor);
 };
@@ -96,20 +96,20 @@ public:
 
 class logical_expr : public expr {
 public:
-    expr* left;
+    std::unique_ptr<expr> left;
     token oper;
-    expr* right;
+    std::unique_ptr<expr> right;
 
-    logical_expr(expr* l, token t, expr* r);
+    logical_expr(std::unique_ptr<expr> left_, token t, std::unique_ptr<expr> right_);
     virtual ~logical_expr();
     void accept(expr_visitor* visitor);
 };
 
 class grouping : public expr {
 public:
-    expr* expression;
+    std::unique_ptr<expr> expression;
 
-    grouping(expr* e);
+    grouping(std::unique_ptr<expr> e);
     virtual ~grouping();
     void accept(expr_visitor* visitor);
 };
\ No newline at end of file
diff --git a/query_language/interpreter.cpp b/query_language/interpreter.cpp
index b4f141e..764051c 100644
--- a/query_language/interpreter.cpp
+++ b/query_language/interpreter.cpp
@@ -2,14 +2,14 @@
 
 interpreter::interpreter() {};
 
-value interpreter::interpret(expr* expression, json card_) {
+value interpreter::interpret(std::unique_ptr<expr> expression, json card_) {
     card = card_;
     value result = evaluate(expression);
     return result;
 }
 
 
-value interpreter::evaluate(expr* expression){
+value interpreter::evaluate( const std::unique_ptr<expr>& expression){
     expression->accept(this);
     return result;
 }
@@ -112,8 +112,6 @@ void interpreter::visit(func_in* expr){
     if (left.val_type == STRING && right.val_type == JSON){
         result = value(find_word_inJson(left.str_val, right.json_val));
     }
-
-
 }	
 
 bool interpreter::find_word_inJson(std::string word, json jsonValue){
@@ -149,7 +147,7 @@ bool interpreter::find_word_inJson(std::string word, json jsonValue){
 
 
 
-void interpreter::visit(unary* expr){
+void interpreter::visit( unary* expr){
     value right = evaluate(expr->ex);
 
     switch(expr->op.type){
diff --git a/query_language/interpreter.h b/query_language/interpreter.h
index 227eb9c..64762c6 100644
--- a/query_language/interpreter.h
+++ b/query_language/interpreter.h
@@ -4,20 +4,20 @@
 class interpreter : expr_visitor {
     public:
     interpreter();
-    value interpret(expr* expression, json card_);
+    value interpret(std::unique_ptr<expr> expression, json card_);
     
     private:
     json card;
     value result;
-    value evaluate(expr* expression);
+    value evaluate(const std::unique_ptr<expr>& expression);
     bool is_truthy(value val);
     bool is_equal(value left, value right);
-    void visit(binary* expr);
-    void visit(grouping* expr);
-    void visit(unary* expr);
-    void visit(literal* expr);
-    void visit(func_in* expr);
-    void visit(logical_expr* ex);
+    void visit( binary* expr);
+    void visit( grouping* expr);
+    void visit( unary* expr);
+    void visit( literal* expr);
+    void visit( func_in* expr);
+    void visit( logical_expr* ex);
     bool find_word_inJson(std::string word, json jsonValue);
     void check_number_operand(token oper, value operand);
     void check_number_operands(token oper, value left, value right);
diff --git a/query_language/main.cpp b/query_language/main.cpp
index 3120850..5de65ab 100644
--- a/query_language/main.cpp
+++ b/query_language/main.cpp
@@ -41,31 +41,16 @@ int main(){
 
     json jsonCard = card_to_json(card);
    
-    /*std::string jsonString = jsonCard.dump();
-    std::cout << jsonString << std::endl;*/
-
-    /*scanner scan("(pos[$SELF][data][256]!");
-    std::vector<token> vec= scan.scan_tokens();
-    for(int i = 0; i < vec.size();++i){
-        std::cout<<vec[i].lexeme<<std::endl;
-        if (vec[i].type == tt::ANY){
-            std::cout<<"ANYYYYYY"<<std::endl;
-        }else if(vec[i].type == tt::IDENTIFIER){
-            std::cout<<"indent"<<std::endl;
-        }else if(vec[i].type == tt::NUMBER){
-            std::cout<<"num"<<std::endl;
-        }
-    }*/
-    scanner scan("\"audio1.mp3\" in (audio_links)");
+    scanner scan("\"audio1.mp3\" in (audio_links) and (23<19+5)");
     std::vector<token> tokens= scan.scan_tokens();
     /*for(int i = 0; i < tokens.size();++i){
         std::cout<<tokens[i].lexeme<<" "<<i<<std::endl;
     }*/
 
     parser p(tokens);
-    expr* exp = p.parse();
+    std::unique_ptr<expr> exp = p.parse();
     interpreter inter;
-    value val = inter.interpret(exp, jsonCard);
+    value val = inter.interpret(std::move(exp), jsonCard);
     if (val.val_type == DOUBLE){
         std::cout<<"значение: "<<val.doub_val<< std::endl;
     } else if (val.val_type == JSON){
@@ -79,8 +64,6 @@ int main(){
         std::cout<<"значение: "<<val.str_val<< std::endl;
     } else if (val.val_type == EMPTY){
         std::cout<<"пусто"<< std::endl;
-    } 
-    delete exp;
-    
+    }   
     return 0;
 }
\ No newline at end of file
diff --git a/query_language/parcer.cpp b/query_language/parcer.cpp
index 257a499..49dd627 100644
--- a/query_language/parcer.cpp
+++ b/query_language/parcer.cpp
@@ -35,29 +35,25 @@ bool parser::match(std::vector<token_type> types){
 }
 
 // потом заманить ifы
-expr* parser::primary(){
+std::unique_ptr<expr> parser::primary(){
     if (match({tt::FALSE}))
-        return new literal(false);
+        return std::make_unique<literal>(false);
     if (match({tt::TRUE}))
-        return new literal(true);
+        return std::make_unique<literal>(true);
     if (match({tt::NUMBER})){
-        return new literal(std::stod(previous().literal));
+        return std::make_unique<literal>(std::stod(previous().literal));
     }
     if (match({tt::STRING}))
-        return new literal(previous().literal);
+        return std::make_unique<literal>(previous().literal);
     if (match({tt::LEFT_PAREN})){
-        expr* expr = expression();
+        std::unique_ptr<expr> expr = expression();
         // обработать, что нет правой скобки
-        return new grouping(expr);
+        return std::make_unique<grouping>(std::move(expr));
     }
     if (match({tt::IDENTIFIER})){
-        std::cout<<"индентифайер"<< std::endl;
         std::vector<std::string> json_fields = read_json_elem();
         if(!json_fields.empty()){
-            for(int i = 0; i < json_fields.size(); ++i){
-                std::cout<<json_fields[i]<< std::endl;
-            }
-            return new literal(json_fields);
+            return std::make_unique<literal>(json_fields);
         } // обработать ошибку
     }
     return nullptr;
@@ -82,13 +78,13 @@ std::vector<std::string> parser::read_json_elem(){
 
 
 
-expr* parser::func_in_class(){
-    expr* left = primary();
+std::unique_ptr<expr> parser::func_in_class(){
+    std::unique_ptr<expr>  left = primary();
     if(match({tt::IN})){
         if(match({tt::LEFT_PAREN})){
-            expr* right = primary();
+            std::unique_ptr<expr>  right = primary();
             if(match({tt::RIGHT_PAREN})){
-                return new func_in(left, right);
+                return std::make_unique<func_in>(std::move(left), std::move(right));
             }
         }
     }
@@ -96,99 +92,89 @@ expr* parser::func_in_class(){
 }
 
 
-expr* parser::unar(){
+std::unique_ptr<expr> parser::unar(){
     if(match({tt::BANG, tt::MINUS})){
         token oper = previous();
-        expr* right = unar();
-        return new unary(right, oper);
+        std::unique_ptr<expr> right = unar();
+        return std::make_unique<unary>(std::move(right),oper);
     }
     return func_in_class();
 }
 
-expr* parser::multiplication(){
-    expr* expression = unar();
+std::unique_ptr<expr> parser::multiplication(){
+    std::unique_ptr<expr> expression = unar();
     while(match({tt::SLASH, tt::STAR})){
         token oper = previous();
-        expr* right = unar();
-        expression = new binary(expression, oper, right);
+        std::unique_ptr<expr> right = unar();
+        expression = std::make_unique<binary>(std::move(expression), oper, std::move(right));
     }
     return expression;
 }
 
-expr* parser::addition(){
-    expr* expression = multiplication();
+std::unique_ptr<expr> parser::addition(){
+    std::unique_ptr<expr> expression = multiplication();
     while(match({tt::MINUS, tt::PLUS})){
         std::cout<<"операция + -"<<std::endl;
         token oper = previous();
-        expr* right = multiplication();
-        expression = new binary(expression, oper, right);
+        std::unique_ptr<expr> right = multiplication();
+        expression = std::make_unique<binary>(std::move(expression), oper, std::move(right));
     }
     return expression;
 }
 
-expr* parser::comparison(){
-    expr* expression = addition();
+std::unique_ptr<expr> parser::comparison(){
+     std::unique_ptr<expr> expression = addition();
     while(match({tt::LESS, tt::LESS_EQUAL, tt::GREATER, tt::GREATER_EQUAL})){
         token oper = previous();
-        expr* right = addition();
-        expression = new binary(expression, oper, right);
+         std::unique_ptr<expr> right = addition();
+        expression = std::make_unique<binary>(std::move(expression), oper, std::move(right));
     }
     return expression;
 }
 
-expr* parser::equality(){
-    expr* expression = comparison();
+std::unique_ptr<expr> parser::equality(){
+    std::unique_ptr<expr> expression = comparison();
     while(match({tt::BANG_EQUAL,tt::EQUAL_EQUAL})){
         token oper = previous();
-        expr* right = comparison();
-        expression = new binary(expression, oper, right);
+        std::unique_ptr<expr> right = comparison();
+        expression = std::make_unique<binary>(std::move(expression), oper, std::move(right));
     }
     return expression;
 }
 
-expr* parser::_and(){
-    expr* left = equality();
+std::unique_ptr<expr>  parser::_and(){
+    std::unique_ptr<expr>  left = equality();
 
     while(match({tt::AND})){
         token oper = previous();
-        expr* right = equality();
-        left = new logical_expr(left, oper, right);
+        std::unique_ptr<expr>  right = equality();
+         left = std::make_unique<logical_expr>(std::move(left), oper, std::move(right));
     }
     return left;
 }
 
-expr* parser::_or(){
-    expr* left = _and();
-    literal* l = reinterpret_cast<literal*>(left);
+std::unique_ptr<expr> parser::_or(){
+    std::unique_ptr<expr> left = _and();
+//    literal* l = reinterpret_cast<literal*>(left);
     while(match({tt::OR})){
         token oper = previous();
-        expr* right = _and();
-        left = new logical_expr(left, oper, right);
+        std::unique_ptr<expr> right = _and();
+        left = std::make_unique<logical_expr>(std::move(left), oper, std::move(right));
     } 
     return left;
 }
 
 
-expr* parser::expression(){
+std::unique_ptr<expr> parser::expression(){
     return _or();
 }
 
+std::unique_ptr<expr>  parser::parse(){
 
-
-/*expr* parser::function(std::string kind){
-    token name = consume(FUN, std::string("Expect " + kind + " name."));
-    consume(tt::LEFT_PAREN, std::string("Expected '(' after" + kind + " declaration."));
-    std::vector<token> parameters;
-
-   
-    consume(tt::RIGHT_PAREN, std::string("Expected ')' after " + kind + " declaration"));
-    return new fun_stmt(name, parameters);
-}*/
+    return expression();
+  }
 
 
 
-expr*  parser::parse(){
 
-    return expression();
-  }
 
diff --git a/query_language/parcer.h b/query_language/parcer.h
index dc71dc2..d497944 100644
--- a/query_language/parcer.h
+++ b/query_language/parcer.h
@@ -4,7 +4,7 @@
 class parser {
     public:
     parser(std::vector<token>& t);
-    expr* parse();
+    std::unique_ptr<expr> parse();
     
     private:
     std::vector<token> tokens;
@@ -17,18 +17,18 @@ class parser {
     bool check(token_type type);
     bool match(std::vector<token_type> types);
     token consume(token_type type, std::string message);
-    expr* primary();
-    expr* finish_call(expr* callee);
-    expr* func_in_class();
-    expr* unar();
-    expr* multiplication();
-    expr* addition();
-    expr* comparison();
-    expr* equality();
-    expr* _and();
-    expr*_or();
-    expr* assignment();
-    expr* expression();
-    expr* function(std::string kind);
+    std::unique_ptr<expr> primary();
+    std::unique_ptr<expr> finish_call(expr* callee);
+    std::unique_ptr<expr> func_in_class();
+    std::unique_ptr<expr> unar();
+    std::unique_ptr<expr> multiplication();
+    std::unique_ptr<expr> addition();
+    std::unique_ptr<expr> comparison();
+    std::unique_ptr<expr> equality();
+    std::unique_ptr<expr> _and();
+    std::unique_ptr<expr>_or();
+    std::unique_ptr<expr> assignment();
+    std::unique_ptr<expr> expression();
+    std::unique_ptr<expr> function(std::string kind);
 };
 
-- 
GitLab