rename Virtual_column_info::expr_item

now, when expr_str is gone, expr_item can be unambiguously
renamed to expr.

13 files changed, 59 insertions, 59 deletions

diff --git a/sql/field.cc b/sql/field.cc
index 88af4f321dd..bd06314a8bb 100644
--- a/sql/field.cc
+++ b/sql/field.cc
@@ -2310,7 +2310,7 @@ void Field::set_default()
   if (default_value)
   {
     table->in_use->reset_arena_for_cached_items(table->expr_arena);
-    (void) default_value->expr_item->save_in_field(this, 0);
+    (void) default_value->expr->save_in_field(this, 0);
     table->in_use->reset_arena_for_cached_items(0);
     return;
   }
@@ -9788,7 +9788,7 @@ bool check_expression(Virtual_column_info *vcol, const char *name,
     to be part of the virtual column
   */
   res.errors= 0;
-  ret= vcol->expr_item->walk(&Item::check_vcol_func_processor, 0, &res);
+  ret= vcol->expr->walk(&Item::check_vcol_func_processor, 0, &res);
   vcol->flags= res.errors;
 
   uint filter= VCOL_IMPOSSIBLE;
@@ -9805,7 +9805,7 @@ bool check_expression(Virtual_column_info *vcol, const char *name,
     Safe to call before fix_fields as long as vcol's don't include sub
     queries (which is now checked in check_vcol_func_processor)
   */
-  if (vcol->expr_item->check_cols(1))
+  if (vcol->expr->check_cols(1))
     return TRUE;
   return FALSE;
 }
@@ -9821,7 +9821,7 @@ bool Column_definition::check(THD *thd)
   /* Initialize data for a computed field */
   if (vcol_info)
   {
-    DBUG_ASSERT(vcol_info->expr_item);
+    DBUG_ASSERT(vcol_info->expr);
     vcol_info->set_field_type(sql_type);
     if (check_expression(vcol_info, field_name, vcol_info->stored_in_db
                          ? VCOL_GENERATED_STORED : VCOL_GENERATED_VIRTUAL))
@@ -9834,7 +9834,7 @@ bool Column_definition::check(THD *thd)
 
   if (default_value)
   {
-    Item *def_expr= default_value->expr_item;
+    Item *def_expr= default_value->expr;
     if (check_expression(default_value, field_name, VCOL_DEFAULT))
       DBUG_RETURN(TRUE);
 
@@ -9859,15 +9859,15 @@ bool Column_definition::check(THD *thd)
     DBUG_RETURN(1);
   }
 
-  if (default_value && !default_value->expr_item->basic_const_item() &&
+  if (default_value && !default_value->expr->basic_const_item() &&
       mysql_type_to_time_type(sql_type) == MYSQL_TIMESTAMP_DATETIME &&
-      default_value->expr_item->type() == Item::FUNC_ITEM)
+      default_value->expr->type() == Item::FUNC_ITEM)
   {
     /*
       Special case: NOW() for TIMESTAMP and DATETIME fields are handled
       as in MariaDB 10.1 by marking them in unireg_check.
     */
-    Item_func *fn= static_cast<Item_func*>(default_value->expr_item);
+    Item_func *fn= static_cast<Item_func*>(default_value->expr);
     if (fn->functype() == Item_func::NOW_FUNC &&
         (fn->decimals == 0 || fn->decimals >= length))
     {
@@ -10563,7 +10563,7 @@ Column_definition::Column_definition(THD *thd, Field *old_field,
       String *res= orig_field->val_str(&tmp, orig_field->ptr_in_record(dv));
       char *pos= (char*) thd->strmake(res->ptr(), res->length());
       default_value= new (thd->mem_root) Virtual_column_info();
-      default_value->expr_item=
+      default_value->expr=
         new (thd->mem_root) Item_string(thd, pos, res->length(), charset);
       default_value->utf8= 0;
     }
@@ -10627,7 +10627,7 @@ Create_field *Create_field::clone(MEM_ROOT *mem_root) const
 bool Column_definition::has_default_expression()
 {
   return (default_value &&
-          (!default_value->expr_item->basic_const_item() ||
+          (!default_value->expr->basic_const_item() ||
            (flags & BLOB_FLAG)));
 }
 
diff --git a/sql/field.h b/sql/field.h
index 83997c70032..fd62218f144 100644
--- a/sql/field.h
+++ b/sql/field.h
@@ -621,14 +621,14 @@ public:
   /* Flag indicating  that the field is physically stored in the database */
   bool stored_in_db;
   bool utf8;                                    /* Already in utf8 */
-  Item *expr_item;
+  Item *expr;
   LEX_STRING name;                              /* Name of constraint */
   uint flags;
 
   Virtual_column_info()
   : field_type((enum enum_field_types)MYSQL_TYPE_VIRTUAL),
     in_partitioning_expr(FALSE), stored_in_db(FALSE),
-    utf8(TRUE), expr_item(NULL), flags(0)
+    utf8(TRUE), expr(NULL), flags(0)
   {
     name.str= NULL;
     name.length= 0;
diff --git a/sql/filesort.cc b/sql/filesort.cc
index a82f4871045..2210dc569df 100644
--- a/sql/filesort.cc
+++ b/sql/filesort.cc
@@ -1272,7 +1272,7 @@ static void register_used_fields(Sort_param *param)
       {
         if (field->vcol_info)
 	{
-          Item *vcol_item= field->vcol_info->expr_item;
+          Item *vcol_item= field->vcol_info->expr;
           vcol_item->walk(&Item::register_field_in_read_map, 1, 0);
         }                   
         bitmap_set_bit(bitmap, field->field_index);
diff --git a/sql/item.cc b/sql/item.cc
index c8cff0859c0..f8f776a2b28 100644
--- a/sql/item.cc
+++ b/sql/item.cc
@@ -905,7 +905,7 @@ bool Item_field::register_field_in_read_map(void *arg)
   if (field->vcol_info &&
       !bitmap_fast_test_and_set(field->table->vcol_set, field->field_index))
   {
-    res= field->vcol_info->expr_item->walk(&Item::register_field_in_read_map,1,arg);
+    res= field->vcol_info->expr->walk(&Item::register_field_in_read_map,1,arg);
   }
   if (field->table == table || !table)
     bitmap_set_bit(field->table->read_set, field->field_index);
@@ -1000,8 +1000,8 @@ bool Item_field::update_vcol_processor(void *arg)
   if (field->vcol_info &&
       !bitmap_fast_test_and_set(map, field->field_index))
   {
-    field->vcol_info->expr_item->walk(&Item::update_vcol_processor, 0, arg);
-    field->vcol_info->expr_item->save_in_field(field, 0);
+    field->vcol_info->expr->walk(&Item::update_vcol_processor, 0, arg);
+    field->vcol_info->expr->save_in_field(field, 0);
   }
   return 0;
 }
@@ -8642,7 +8642,7 @@ bool Item_default_value::fix_fields(THD *thd, Item **items)
   {
     fix_session_vcol_expr_for_read(thd, field, field->default_value);
     if (thd->mark_used_columns != MARK_COLUMNS_NONE)
-      field->default_value->expr_item->walk(&Item::register_field_in_read_map, 1, 0);
+      field->default_value->expr->walk(&Item::register_field_in_read_map, 1, 0);
     IF_DBUG(def_field->is_stat_field=1,); // a hack to fool ASSERT_COLUMN_MARKED_FOR_WRITE_OR_COMPUTED
   }
   return FALSE;
@@ -10454,9 +10454,9 @@ void Item::register_in(THD *thd)
 
 void Virtual_column_info::print(String *str)
 {
-  expr_item->print(str, (enum_query_type)(QT_ITEM_ORIGINAL_FUNC_NULLIF |
-                   QT_ITEM_IDENT_SKIP_DB_NAMES |
-                   QT_ITEM_IDENT_SKIP_TABLE_NAMES |
-                   QT_ITEM_CACHE_WRAPPER_SKIP_DETAILS |
-                   QT_TO_SYSTEM_CHARSET));
+  expr->print(str, (enum_query_type)(QT_ITEM_ORIGINAL_FUNC_NULLIF |
+                                     QT_ITEM_IDENT_SKIP_DB_NAMES |
+                                     QT_ITEM_IDENT_SKIP_TABLE_NAMES |
+                                     QT_ITEM_CACHE_WRAPPER_SKIP_DETAILS |
+                                     QT_TO_SYSTEM_CHARSET));
 }
diff --git a/sql/item.h b/sql/item.h
index c3128b35c52..9b7f43edb1b 100644
--- a/sql/item.h
+++ b/sql/item.h
@@ -5788,7 +5788,7 @@ inline bool Virtual_column_info::is_equal(const Virtual_column_info* vcol) const
 {
   return field_type == vcol->get_real_type()
       && stored_in_db == vcol->is_stored()
-      && expr_item->eq(vcol->expr_item, true);
+      && expr->eq(vcol->expr, true);
 }
 
 #endif /* SQL_ITEM_INCLUDED */
diff --git a/sql/item_func.cc b/sql/item_func.cc
index b03e65a2431..64e4db80aa9 100644
--- a/sql/item_func.cc
+++ b/sql/item_func.cc
@@ -4747,7 +4747,7 @@ bool Item_func_set_user_var::register_field_in_read_map(void *arg)
       bitmap_set_bit(result_field->table->read_set, result_field->field_index);
     if (result_field->vcol_info)
       return result_field->vcol_info->
-               expr_item->walk(&Item::register_field_in_read_map, 1, arg);
+               expr->walk(&Item::register_field_in_read_map, 1, arg);
   }
   return 0;
 }
diff --git a/sql/sql_base.cc b/sql/sql_base.cc
index 024e9fa1cc7..1ca7e9c1574 100644
--- a/sql/sql_base.cc
+++ b/sql/sql_base.cc
@@ -7950,7 +7950,7 @@ void switch_defaults_to_nullable_trigger_fields(TABLE *table)
     for (Field **field_ptr= table->default_field; *field_ptr ; field_ptr++)
     {
       Field *field= (*field_ptr);
-      field->default_value->expr_item->walk(&Item::switch_to_nullable_fields_processor, 1, trigger_field);
+      field->default_value->expr->walk(&Item::switch_to_nullable_fields_processor, 1, trigger_field);
       *field_ptr= (trigger_field[field->field_index]);
     }
   }
diff --git a/sql/sql_insert.cc b/sql/sql_insert.cc
index f918e547148..901fd485390 100644
--- a/sql/sql_insert.cc
+++ b/sql/sql_insert.cc
@@ -2357,7 +2357,7 @@ end_create:
   if (vcol)                                                               \
   {                                                                       \
     (vcol)= (Virtual_column_info*)(thd)->memdup((vcol), sizeof(*(vcol))); \
-    (vcol)->expr_item= NULL;                                              \
+    (vcol)->expr= NULL;                                                   \
   }
 
 /**
diff --git a/sql/sql_show.cc b/sql/sql_show.cc
index e2f9e9432af..c6a5222f7b0 100644
--- a/sql/sql_show.cc
+++ b/sql/sql_show.cc
@@ -1663,7 +1663,7 @@ static bool get_field_default_value(THD *thd, Field *field, String *def_value,
     if (field->default_value)
     {
       field->default_value->print(&str);
-      if (field->default_value->expr_item->need_parentheses_in_default())
+      if (field->default_value->expr->need_parentheses_in_default())
       {
         def_value->set_charset(&my_charset_utf8mb4_general_ci);
         def_value->append('(');
diff --git a/sql/sql_table.cc b/sql/sql_table.cc
index 1e985bc240b..5ae8fd8270b 100644
--- a/sql/sql_table.cc
+++ b/sql/sql_table.cc
@@ -3345,8 +3345,8 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
       We can only do this for constants as we have not yet run fix_fields.
     */
     if (sql_field->default_value &&
-        sql_field->default_value->expr_item->basic_const_item() &&
-        save_cs != sql_field->default_value->expr_item->collation.collation &&
+        sql_field->default_value->expr->basic_const_item() &&
+        save_cs != sql_field->default_value->expr->collation.collation &&
         (sql_field->sql_type == MYSQL_TYPE_VAR_STRING ||
          sql_field->sql_type == MYSQL_TYPE_STRING ||
          sql_field->sql_type == MYSQL_TYPE_SET ||
@@ -3357,7 +3357,7 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
          sql_field->sql_type == MYSQL_TYPE_ENUM))
     {
       Item *item;
-      if (!(item= sql_field->default_value->expr_item->
+      if (!(item= sql_field->default_value->expr->
             safe_charset_converter(thd, save_cs)))
       {
         /* Could not convert */
@@ -3365,16 +3365,16 @@ mysql_prepare_create_table(THD *thd, HA_CREATE_INFO *create_info,
         DBUG_RETURN(TRUE);
       }
       /* Fix for prepare statement */
-      thd->change_item_tree(&sql_field->default_value->expr_item, item);
+      thd->change_item_tree(&sql_field->default_value->expr, item);
     }
 
     if (sql_field->default_value &&
-        sql_field->default_value->expr_item->basic_const_item() &&
+        sql_field->default_value->expr->basic_const_item() &&
         (sql_field->sql_type == MYSQL_TYPE_SET ||
          sql_field->sql_type == MYSQL_TYPE_ENUM))
     {
       StringBuffer<MAX_FIELD_WIDTH> str;
-      String *def= sql_field->default_value->expr_item->val_str(&str);
+      String *def= sql_field->default_value->expr->val_str(&str);
       bool not_found;
       if (def == NULL) /* SQL "NULL" maps to NULL */
       {
@@ -6412,7 +6412,7 @@ static bool fill_alter_inplace_info(THD *thd,
               uses DEFAULT() function. The check is kind of expensive, so don't
               do it if ALTER_COLUMN_VCOL is already set.
             */
-            if (field->vcol_info->expr_item->walk(
+            if (field->vcol_info->expr->walk(
                                  &Item::check_func_default_processor, 0, 0))
             {
               ha_alter_info->handler_flags|= alter_expr;
diff --git a/sql/sql_yacc.yy b/sql/sql_yacc.yy
index 1885c2e5aa5..55c5767d636 100644
--- a/sql/sql_yacc.yy
+++ b/sql/sql_yacc.yy
@@ -918,7 +918,7 @@ Virtual_column_info *add_virtual_expression(THD *thd, Item *expr)
      mem_alloc_error(sizeof(Virtual_column_info));
      return 0;
    }
-   v->expr_item= expr;
+   v->expr= expr;
    v->utf8= 0;  /* connection charset */
    return v;
 }
diff --git a/sql/table.cc b/sql/table.cc
index 848352419d5..79f7a6d5d12 100644
--- a/sql/table.cc
+++ b/sql/table.cc
@@ -1039,7 +1039,7 @@ bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table,
     case VCOL_GENERATED_STORED:
       vcol= unpack_vcol_info_from_frm(thd, mem_root, table, pos, expr_length,
                                       (*field_ptr)->vcol_info, error_reported);
-      DBUG_ASSERT((*field_ptr)->vcol_info->expr_item == NULL);
+      DBUG_ASSERT((*field_ptr)->vcol_info->expr == NULL);
       (*field_ptr)->vcol_info= vcol;
       *(vfield_ptr++)= *field_ptr;
       break;
@@ -1047,7 +1047,7 @@ bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table,
       vcol= unpack_vcol_info_from_frm(thd, mem_root, table, pos, expr_length,
                                       (*field_ptr)->default_value,
                                       error_reported);
-      DBUG_ASSERT((*field_ptr)->default_value->expr_item == NULL);
+      DBUG_ASSERT((*field_ptr)->default_value->expr == NULL);
       (*field_ptr)->default_value= vcol;
       *(dfield_ptr++)= *field_ptr;
       break;
@@ -1055,7 +1055,7 @@ bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table,
       vcol= unpack_vcol_info_from_frm(thd, mem_root, table, pos, expr_length,
                                       (*field_ptr)->check_constraint,
                                       error_reported);
-      DBUG_ASSERT((*field_ptr)->check_constraint->expr_item == NULL);
+      DBUG_ASSERT((*field_ptr)->check_constraint->expr == NULL);
       (*field_ptr)->check_constraint= vcol;
       *check_constraint_ptr++= vcol;
       break;
@@ -1081,10 +1081,10 @@ bool parse_vcol_defs(THD *thd, MEM_ROOT *mem_root, TABLE *table,
       vcol= unpack_vcol_info_from_frm(thd, mem_root, table, (uchar*)buf, len,
                                       (*field_ptr)->default_value,
                                       error_reported);
-      DBUG_ASSERT((*field_ptr)->default_value->expr_item == NULL);
+      DBUG_ASSERT((*field_ptr)->default_value->expr == NULL);
       (*field_ptr)->default_value= vcol;
       *(dfield_ptr++)= *field_ptr;
-      if (!field->default_value->expr_item)
+      if (!field->default_value->expr)
         DBUG_RETURN(1);
     }
     else if (field->has_update_default_function() && !field->default_value)
@@ -2663,7 +2663,7 @@ static bool fix_vcol_expr(THD *thd, Virtual_column_info *vcol)
   const char *save_where= thd->where;
   thd->where= "virtual column function";
 
-  int error= vcol->expr_item->fix_fields(thd, &vcol->expr_item);
+  int error= vcol->expr->fix_fields(thd, &vcol->expr);
 
   thd->mark_used_columns= save_mark_used_columns;
   thd->where= save_where;
@@ -2690,8 +2690,8 @@ bool fix_session_vcol_expr(THD *thd, Virtual_column_info *vcol)
   if (!(vcol->flags & (VCOL_TIME_FUNC|VCOL_SESSION_FUNC)))
     DBUG_RETURN(0);
 
-  vcol->expr_item->cleanup();
-  DBUG_ASSERT(!vcol->expr_item->fixed);
+  vcol->expr->cleanup();
+  DBUG_ASSERT(!vcol->expr->fixed);
   DBUG_RETURN(fix_vcol_expr(thd, vcol));
 }
 
@@ -2747,7 +2747,7 @@ bool fix_session_vcol_expr_for_read(THD *thd, Field *field,
 static bool fix_and_check_vcol_expr(THD *thd, TABLE *table,
                                     Virtual_column_info *vcol)
 {
-  Item* func_expr= vcol->expr_item;
+  Item* func_expr= vcol->expr;
   DBUG_ENTER("fix_and_check_vcol_expr");
   DBUG_PRINT("info", ("vcol: %p", vcol));
   DBUG_ASSERT(func_expr);
@@ -2762,7 +2762,7 @@ static bool fix_and_check_vcol_expr(THD *thd, TABLE *table,
     DBUG_RETURN(0); // already checked, no need to do it again
 
   /* fix_fields could've changed the expression */
-  func_expr= vcol->expr_item;
+  func_expr= vcol->expr;
 
   /* this was checked in check_expression(), but the frm could be mangled... */
   if (unlikely(func_expr->result_type() == ROW_RESULT))
@@ -2941,7 +2941,7 @@ end:
 static bool check_vcol_forward_refs(Field *field, Virtual_column_info *vcol)
 {
   bool res= vcol &&
-            vcol->expr_item->walk(&Item::check_field_expression_processor, 0,
+            vcol->expr->walk(&Item::check_field_expression_processor, 0,
                                   field);
   return res;
 }
@@ -5077,7 +5077,7 @@ int TABLE::verify_constraints(bool ignore_failure)
   {
     for (Virtual_column_info **chk= check_constraints ; *chk ; chk++)
     {
-      if ((*chk)->expr_item->val_int() == 0)
+      if ((*chk)->expr->val_int() == 0)
       {
         my_error(ER_CONSTRAINT_FAILED,
                  MYF(ignore_failure ? ME_JUST_WARNING : 0), (*chk)->name.str,
@@ -6187,9 +6187,9 @@ void TABLE::mark_columns_used_by_index_no_reset(uint index,
   {
     bitmap_set_bit(bitmap, key_part->fieldnr-1);
     if (key_part->field->vcol_info &&
-        key_part->field->vcol_info->expr_item)
+        key_part->field->vcol_info->expr)
       key_part->field->vcol_info->
-               expr_item->walk(&Item::register_field_in_bitmap, 1, bitmap);
+               expr->walk(&Item::register_field_in_bitmap, 1, bitmap);
   }
 }
 
@@ -6553,7 +6553,7 @@ bool TABLE::mark_virtual_col(Field *field)
   DBUG_ASSERT(field->vcol_info);
   if (!(res= bitmap_fast_test_and_set(vcol_set, field->field_index)))
   {
-    Item *vcol_item= field->vcol_info->expr_item;
+    Item *vcol_item= field->vcol_info->expr;
     DBUG_ASSERT(vcol_item);
     vcol_item->walk(&Item::register_field_in_read_map, 1, 0);
   }
@@ -6611,7 +6611,7 @@ bool TABLE::mark_virtual_columns_for_write(bool insert_fl)
       else
       {
         MY_BITMAP *save_read_set= read_set, *save_vcol_set= vcol_set;
-        Item *vcol_item= tmp_vfield->vcol_info->expr_item;
+        Item *vcol_item= tmp_vfield->vcol_info->expr;
         DBUG_ASSERT(vcol_item);
         bitmap_clear_all(&tmp_set);
         read_set= vcol_set= &tmp_set;
@@ -6652,7 +6652,7 @@ void TABLE::mark_columns_used_by_check_constraints(void)
   read_set= s->check_set;
 
   for (Virtual_column_info **chk= check_constraints ; *chk ; chk++)
-    (*chk)->expr_item->walk(&Item::register_field_in_read_map, 1, 0);
+    (*chk)->expr->walk(&Item::register_field_in_read_map, 1, 0);
 
   read_set= save_read_set;
   s->check_set_initialized= 1;
@@ -6680,7 +6680,7 @@ void TABLE::mark_default_fields_for_write(bool is_insert)
     if (is_insert && field->default_value)
     {
       bitmap_set_bit(write_set, field->field_index);
-      field->default_value->expr_item->
+      field->default_value->expr->
         walk(&Item::register_field_in_read_map, 1, 0);
     }
     else if (!is_insert && field->has_update_default_function())
@@ -7355,7 +7355,7 @@ int TABLE::update_virtual_fields(enum_vcol_update_mode update_mode)
     vf= (*vfield_ptr);
     Virtual_column_info *vcol_info= vf->vcol_info;
     DBUG_ASSERT(vcol_info);
-    DBUG_ASSERT(vcol_info->expr_item);
+    DBUG_ASSERT(vcol_info->expr);
 
     bool update;
     switch (update_mode) {
@@ -7382,7 +7382,7 @@ int TABLE::update_virtual_fields(enum_vcol_update_mode update_mode)
     if (update)
     {
       /* Compute the actual value of the virtual fields */
-      vcol_info->expr_item->save_in_field(vf, 0);
+      vcol_info->expr->save_in_field(vf, 0);
       DBUG_PRINT("info", ("field '%s' - updated", vf->field_name));
     }
     else
@@ -7400,8 +7400,8 @@ int TABLE::update_virtual_field(Field *vf)
 
   in_use->reset_arena_for_cached_items(expr_arena);
   bitmap_clear_all(&tmp_set);
-  vf->vcol_info->expr_item->walk(&Item::update_vcol_processor, 0, &tmp_set);
-  vf->vcol_info->expr_item->save_in_field(vf, 0);
+  vf->vcol_info->expr->walk(&Item::update_vcol_processor, 0, &tmp_set);
+  vf->vcol_info->expr->save_in_field(vf, 0);
   in_use->reset_arena_for_cached_items(0);
   DBUG_RETURN(0);
 }
@@ -7450,7 +7450,7 @@ int TABLE::update_default_fields(bool update_command, bool ignore_errors)
       {
         if (field->default_value &&
             (field->default_value->flags || field->flags & BLOB_FLAG))
-          res|= (field->default_value->expr_item->save_in_field(field, 0) < 0);
+          res|= (field->default_value->expr->save_in_field(field, 0) < 0);
       }
       else
         res|= field->evaluate_update_default_function();
diff --git a/sql/unireg.cc b/sql/unireg.cc
index c102835a7bb..959f8341a90 100644
--- a/sql/unireg.cc
+++ b/sql/unireg.cc
@@ -981,7 +981,7 @@ static bool make_empty_rec(THD *thd, uchar *buff, uint table_options,
     if (field->default_value && !field->default_value->flags &&
         !(field->flags & BLOB_FLAG))
     {
-      Item *expr= field->default_value->expr_item;
+      Item *expr= field->default_value->expr;
       int res= !expr->fixed && // may be already fixed if ALTER TABLE
                 expr->fix_fields(thd, &expr);
       if (!res)