← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item_cmpfunc.cc

Merged from trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/item_cmpfunc.cc
204
204
  uint i;
205
205
  uint found_types;
206
206
  Item_result left_result= items[0]->result_type();
207
 
  DBUG_ASSERT(nitems > 1);
 
207
  assert(nitems > 1);
208
208
  found_types= 0;
209
209
  for (i= 1; i < nitems ; i++)
210
210
  {
271
271
 
272
272
longlong Item_func_not::val_int()
273
273
{
274
 
  DBUG_ASSERT(fixed == 1);
 
274
  assert(fixed == 1);
275
275
  bool value= args[0]->val_bool();
276
276
  null_value=args[0]->null_value;
277
277
  return ((!null_value && value == 0) ? 1 : 0);
300
300
 
301
301
longlong Item_func_not_all::val_int()
302
302
{
303
 
  DBUG_ASSERT(fixed == 1);
 
303
  assert(fixed == 1);
304
304
  bool value= args[0]->val_bool();
305
305
 
306
306
  /*
341
341
 
342
342
longlong Item_func_nop_all::val_int()
343
343
{
344
 
  DBUG_ASSERT(fixed == 1);
 
344
  assert(fixed == 1);
345
345
  longlong value= args[0]->val_int();
346
346
 
347
347
  /*
427
427
    {
428
428
      result= field->store(orig_field_val, true);
429
429
      /* orig_field_val must be a valid value that can be restored back. */
430
 
      DBUG_ASSERT(!result);
 
430
      assert(!result);
431
431
    }
432
432
    thd->variables.sql_mode= orig_sql_mode;
433
433
    thd->count_cuted_fields= orig_count_cuted_fields;
619
619
    break;
620
620
  }
621
621
  default:
622
 
    DBUG_ASSERT(0);
 
622
    assert(0);
623
623
  }
624
624
  return 0;
625
625
}
1500
1500
 
1501
1501
bool Item_in_optimizer::fix_fields(THD *thd, Item **ref)
1502
1502
{
1503
 
  DBUG_ASSERT(fixed == 0);
 
1503
  assert(fixed == 0);
1504
1504
  if (fix_left(thd, ref))
1505
1505
    return true;
1506
1506
  if (args[0]->maybe_null)
1528
1528
longlong Item_in_optimizer::val_int()
1529
1529
{
1530
1530
  bool tmp;
1531
 
  DBUG_ASSERT(fixed == 1);
 
1531
  assert(fixed == 1);
1532
1532
  cache->store(args[0]);
1533
1533
  
1534
1534
  if (cache->null_value)
1606
1606
 
1607
1607
void Item_in_optimizer::cleanup()
1608
1608
{
1609
 
  DBUG_ENTER("Item_in_optimizer::cleanup");
1610
1609
  Item_bool_func::cleanup();
1611
1610
  if (!save_cache)
1612
1611
    cache= 0;
1613
 
  DBUG_VOID_RETURN;
 
1612
  return;
1614
1613
}
1615
1614
 
1616
1615
 
1647
1646
{
1648
1647
  Item *new_item;
1649
1648
 
1650
 
  DBUG_ASSERT(arg_count == 2);
 
1649
  assert(arg_count == 2);
1651
1650
 
1652
1651
  /* Transform the left IN operand. */
1653
1652
  new_item= (*args)->transform(transformer, argument);
1669
1668
    transformation, we only make both operands the same.
1670
1669
    TODO: is it the way it should be?
1671
1670
  */
1672
 
  DBUG_ASSERT((args[1])->type() == Item::SUBSELECT_ITEM &&
 
1671
  assert((args[1])->type() == Item::SUBSELECT_ITEM &&
1673
1672
              (((Item_subselect*)(args[1]))->substype() ==
1674
1673
               Item_subselect::IN_SUBS ||
1675
1674
               ((Item_subselect*)(args[1]))->substype() ==
1687
1686
 
1688
1687
longlong Item_func_eq::val_int()
1689
1688
{
1690
 
  DBUG_ASSERT(fixed == 1);
 
1689
  assert(fixed == 1);
1691
1690
  int value= cmp.compare();
1692
1691
  return value == 0 ? 1 : 0;
1693
1692
}
1703
1702
 
1704
1703
longlong Item_func_equal::val_int()
1705
1704
{
1706
 
  DBUG_ASSERT(fixed == 1);
 
1705
  assert(fixed == 1);
1707
1706
  return cmp.compare();
1708
1707
}
1709
1708
 
1710
1709
longlong Item_func_ne::val_int()
1711
1710
{
1712
 
  DBUG_ASSERT(fixed == 1);
 
1711
  assert(fixed == 1);
1713
1712
  int value= cmp.compare();
1714
1713
  return value != 0 && !null_value ? 1 : 0;
1715
1714
}
1717
1716
 
1718
1717
longlong Item_func_ge::val_int()
1719
1718
{
1720
 
  DBUG_ASSERT(fixed == 1);
 
1719
  assert(fixed == 1);
1721
1720
  int value= cmp.compare();
1722
1721
  return value >= 0 ? 1 : 0;
1723
1722
}
1725
1724
 
1726
1725
longlong Item_func_gt::val_int()
1727
1726
{
1728
 
  DBUG_ASSERT(fixed == 1);
 
1727
  assert(fixed == 1);
1729
1728
  int value= cmp.compare();
1730
1729
  return value > 0 ? 1 : 0;
1731
1730
}
1732
1731
 
1733
1732
longlong Item_func_le::val_int()
1734
1733
{
1735
 
  DBUG_ASSERT(fixed == 1);
 
1734
  assert(fixed == 1);
1736
1735
  int value= cmp.compare();
1737
1736
  return value <= 0 && !null_value ? 1 : 0;
1738
1737
}
1740
1739
 
1741
1740
longlong Item_func_lt::val_int()
1742
1741
{
1743
 
  DBUG_ASSERT(fixed == 1);
 
1742
  assert(fixed == 1);
1744
1743
  int value= cmp.compare();
1745
1744
  return value < 0 && !null_value ? 1 : 0;
1746
1745
}
1748
1747
 
1749
1748
longlong Item_func_strcmp::val_int()
1750
1749
{
1751
 
  DBUG_ASSERT(fixed == 1);
 
1750
  assert(fixed == 1);
1752
1751
  String *a=args[0]->val_str(&tmp_value1);
1753
1752
  String *b=args[1]->val_str(&tmp_value2);
1754
1753
  if (!a || !b)
1863
1862
 
1864
1863
longlong Item_func_interval::val_int()
1865
1864
{
1866
 
  DBUG_ASSERT(fixed == 1);
 
1865
  assert(fixed == 1);
1867
1866
  double value;
1868
1867
  my_decimal dec_buf, *dec= NULL;
1869
1868
  uint i;
2062
2061
 
2063
2062
longlong Item_func_between::val_int()
2064
2063
{                                               // ANSI BETWEEN
2065
 
  DBUG_ASSERT(fixed == 1);
 
2064
  assert(fixed == 1);
2066
2065
  if (compare_as_dates)
2067
2066
  {
2068
2067
    int ge_res, le_res;
2216
2215
    break;
2217
2216
  case ROW_RESULT:
2218
2217
  default:
2219
 
    DBUG_ASSERT(0);
 
2218
    assert(0);
2220
2219
  }
2221
2220
  cached_field_type= agg_field_type(args, 2);
2222
2221
}
2242
2241
double
2243
2242
Item_func_ifnull::real_op()
2244
2243
{
2245
 
  DBUG_ASSERT(fixed == 1);
 
2244
  assert(fixed == 1);
2246
2245
  double value= args[0]->val_real();
2247
2246
  if (!args[0]->null_value)
2248
2247
  {
2258
2257
longlong
2259
2258
Item_func_ifnull::int_op()
2260
2259
{
2261
 
  DBUG_ASSERT(fixed == 1);
 
2260
  assert(fixed == 1);
2262
2261
  longlong value=args[0]->val_int();
2263
2262
  if (!args[0]->null_value)
2264
2263
  {
2274
2273
 
2275
2274
my_decimal *Item_func_ifnull::decimal_op(my_decimal *decimal_value)
2276
2275
{
2277
 
  DBUG_ASSERT(fixed == 1);
 
2276
  assert(fixed == 1);
2278
2277
  my_decimal *value= args[0]->val_decimal(decimal_value);
2279
2278
  if (!args[0]->null_value)
2280
2279
  {
2291
2290
String *
2292
2291
Item_func_ifnull::str_op(String *str)
2293
2292
{
2294
 
  DBUG_ASSERT(fixed == 1);
 
2293
  assert(fixed == 1);
2295
2294
  String *res  =args[0]->val_str(str);
2296
2295
  if (!args[0]->null_value)
2297
2296
  {
2336
2335
bool
2337
2336
Item_func_if::fix_fields(THD *thd, Item **ref)
2338
2337
{
2339
 
  DBUG_ASSERT(fixed == 0);
 
2338
  assert(fixed == 0);
2340
2339
  args[0]->top_level_item();
2341
2340
 
2342
2341
  if (Item_func::fix_fields(thd, ref))
2415
2414
double
2416
2415
Item_func_if::val_real()
2417
2416
{
2418
 
  DBUG_ASSERT(fixed == 1);
 
2417
  assert(fixed == 1);
2419
2418
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
2420
2419
  double value= arg->val_real();
2421
2420
  null_value=arg->null_value;
2425
2424
longlong
2426
2425
Item_func_if::val_int()
2427
2426
{
2428
 
  DBUG_ASSERT(fixed == 1);
 
2427
  assert(fixed == 1);
2429
2428
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
2430
2429
  longlong value=arg->val_int();
2431
2430
  null_value=arg->null_value;
2435
2434
String *
2436
2435
Item_func_if::val_str(String *str)
2437
2436
{
2438
 
  DBUG_ASSERT(fixed == 1);
 
2437
  assert(fixed == 1);
2439
2438
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
2440
2439
  String *res=arg->val_str(str);
2441
2440
  if (res)
2448
2447
my_decimal *
2449
2448
Item_func_if::val_decimal(my_decimal *decimal_value)
2450
2449
{
2451
 
  DBUG_ASSERT(fixed == 1);
 
2450
  assert(fixed == 1);
2452
2451
  Item *arg= args[0]->val_bool() ? args[1] : args[2];
2453
2452
  my_decimal *value= arg->val_decimal(decimal_value);
2454
2453
  null_value= arg->null_value;
2487
2486
double
2488
2487
Item_func_nullif::val_real()
2489
2488
{
2490
 
  DBUG_ASSERT(fixed == 1);
 
2489
  assert(fixed == 1);
2491
2490
  double value;
2492
2491
  if (!cmp.compare())
2493
2492
  {
2502
2501
longlong
2503
2502
Item_func_nullif::val_int()
2504
2503
{
2505
 
  DBUG_ASSERT(fixed == 1);
 
2504
  assert(fixed == 1);
2506
2505
  longlong value;
2507
2506
  if (!cmp.compare())
2508
2507
  {
2517
2516
String *
2518
2517
Item_func_nullif::val_str(String *str)
2519
2518
{
2520
 
  DBUG_ASSERT(fixed == 1);
 
2519
  assert(fixed == 1);
2521
2520
  String *res;
2522
2521
  if (!cmp.compare())
2523
2522
  {
2533
2532
my_decimal *
2534
2533
Item_func_nullif::val_decimal(my_decimal * decimal_value)
2535
2534
{
2536
 
  DBUG_ASSERT(fixed == 1);
 
2535
  assert(fixed == 1);
2537
2536
  my_decimal *res;
2538
2537
  if (!cmp.compare())
2539
2538
  {
2594
2593
    for (uint i=0 ; i < ncases ; i+=2)
2595
2594
    {
2596
2595
      cmp_type= item_cmp_type(left_result_type, args[i]->result_type());
2597
 
      DBUG_ASSERT(cmp_type != ROW_RESULT);
2598
 
      DBUG_ASSERT(cmp_items[(uint)cmp_type]);
 
2596
      assert(cmp_type != ROW_RESULT);
 
2597
      assert(cmp_items[(uint)cmp_type]);
2599
2598
      if (!(value_added_map & (1<<(uint)cmp_type)))
2600
2599
      {
2601
2600
        cmp_items[(uint)cmp_type]->store_value(args[first_expr_num]);
2614
2613
 
2615
2614
String *Item_func_case::val_str(String *str)
2616
2615
{
2617
 
  DBUG_ASSERT(fixed == 1);
 
2616
  assert(fixed == 1);
2618
2617
  String *res;
2619
2618
  Item *item=find_item(str);
2620
2619
 
2632
2631
 
2633
2632
longlong Item_func_case::val_int()
2634
2633
{
2635
 
  DBUG_ASSERT(fixed == 1);
 
2634
  assert(fixed == 1);
2636
2635
  char buff[MAX_FIELD_WIDTH];
2637
2636
  String dummy_str(buff,sizeof(buff),default_charset());
2638
2637
  Item *item=find_item(&dummy_str);
2650
2649
 
2651
2650
double Item_func_case::val_real()
2652
2651
{
2653
 
  DBUG_ASSERT(fixed == 1);
 
2652
  assert(fixed == 1);
2654
2653
  char buff[MAX_FIELD_WIDTH];
2655
2654
  String dummy_str(buff,sizeof(buff),default_charset());
2656
2655
  Item *item=find_item(&dummy_str);
2669
2668
 
2670
2669
my_decimal *Item_func_case::val_decimal(my_decimal *decimal_value)
2671
2670
{
2672
 
  DBUG_ASSERT(fixed == 1);
 
2671
  assert(fixed == 1);
2673
2672
  char buff[MAX_FIELD_WIDTH];
2674
2673
  String dummy_str(buff, sizeof(buff), default_charset());
2675
2674
  Item *item= find_item(&dummy_str);
2768
2767
    {
2769
2768
      if (found_types & (1 << i) && !cmp_items[i])
2770
2769
      {
2771
 
        DBUG_ASSERT((Item_result)i != ROW_RESULT);
 
2770
        assert((Item_result)i != ROW_RESULT);
2772
2771
        if ((Item_result)i == STRING_RESULT &&
2773
2772
            agg_arg_charsets(cmp_collation, agg, nagg, MY_COLL_CMP_CONV, 1))
2774
2773
          return;
2851
2850
void Item_func_case::cleanup()
2852
2851
{
2853
2852
  uint i;
2854
 
  DBUG_ENTER("Item_func_case::cleanup");
2855
2853
  Item_func::cleanup();
2856
2854
  for (i= 0; i <= (uint)DECIMAL_RESULT; i++)
2857
2855
  {
2858
2856
    delete cmp_items[i];
2859
2857
    cmp_items[i]= 0;
2860
2858
  }
2861
 
  DBUG_VOID_RETURN;
 
2859
  return;
2862
2860
}
2863
2861
 
2864
2862
 
2868
2866
 
2869
2867
String *Item_func_coalesce::str_op(String *str)
2870
2868
{
2871
 
  DBUG_ASSERT(fixed == 1);
 
2869
  assert(fixed == 1);
2872
2870
  null_value=0;
2873
2871
  for (uint i=0 ; i < arg_count ; i++)
2874
2872
  {
2882
2880
 
2883
2881
longlong Item_func_coalesce::int_op()
2884
2882
{
2885
 
  DBUG_ASSERT(fixed == 1);
 
2883
  assert(fixed == 1);
2886
2884
  null_value=0;
2887
2885
  for (uint i=0 ; i < arg_count ; i++)
2888
2886
  {
2896
2894
 
2897
2895
double Item_func_coalesce::real_op()
2898
2896
{
2899
 
  DBUG_ASSERT(fixed == 1);
 
2897
  assert(fixed == 1);
2900
2898
  null_value=0;
2901
2899
  for (uint i=0 ; i < arg_count ; i++)
2902
2900
  {
2911
2909
 
2912
2910
my_decimal *Item_func_coalesce::decimal_op(my_decimal *decimal_value)
2913
2911
{
2914
 
  DBUG_ASSERT(fixed == 1);
 
2912
  assert(fixed == 1);
2915
2913
  null_value= 0;
2916
2914
  for (uint i= 0; i < arg_count; i++)
2917
2915
  {
2946
2944
    break;
2947
2945
  case ROW_RESULT:
2948
2946
  default:
2949
 
    DBUG_ASSERT(0);
 
2947
    assert(0);
2950
2948
  }
2951
2949
}
2952
2950
 
3167
3165
 
3168
3166
void in_row::set(uint pos, Item *item)
3169
3167
{
3170
 
  DBUG_ENTER("in_row::set");
3171
 
  DBUG_PRINT("enter", ("pos: %u  item: 0x%lx", pos, (ulong) item));
3172
3168
  ((cmp_item_row*) base)[pos].store_value_by_template(&tmp, item);
3173
 
  DBUG_VOID_RETURN;
 
3169
  return;
3174
3170
}
3175
3171
 
3176
3172
in_longlong::in_longlong(uint elements)
3275
3271
  case DECIMAL_RESULT:
3276
3272
    return new cmp_item_decimal;
3277
3273
  default:
3278
 
    DBUG_ASSERT(0);
 
3274
    assert(0);
3279
3275
    break;
3280
3276
  }
3281
3277
  return 0; // to satisfy compiler :)
3305
3301
 
3306
3302
cmp_item_row::~cmp_item_row()
3307
3303
{
3308
 
  DBUG_ENTER("~cmp_item_row");
3309
 
  DBUG_PRINT("enter",("this: 0x%lx", (long) this));
3310
3304
  if (comparators)
3311
3305
  {
3312
3306
    for (uint i= 0; i < n; i++)
3315
3309
        delete comparators[i];
3316
3310
    }
3317
3311
  }
3318
 
  DBUG_VOID_RETURN;
 
3312
  return;
3319
3313
}
3320
3314
 
3321
3315
 
3328
3322
 
3329
3323
void cmp_item_row::store_value(Item *item)
3330
3324
{
3331
 
  DBUG_ENTER("cmp_item_row::store_value");
3332
3325
  n= item->cols();
3333
3326
  alloc_comparators();
3334
3327
  if (comparators)
3346
3339
      item->null_value|= item->element_index(i)->null_value;
3347
3340
    }
3348
3341
  }
3349
 
  DBUG_VOID_RETURN;
 
3342
  return;
3350
3343
}
3351
3344
 
3352
3345
 
3722
3715
        array= new in_decimal(arg_count - 1);
3723
3716
        break;
3724
3717
      default:
3725
 
        DBUG_ASSERT(0);
 
3718
        assert(0);
3726
3719
        return;
3727
3720
      }
3728
3721
    }
3807
3800
longlong Item_func_in::val_int()
3808
3801
{
3809
3802
  cmp_item *in_item;
3810
 
  DBUG_ASSERT(fixed == 1);
 
3803
  assert(fixed == 1);
3811
3804
  uint value_added_map= 0;
3812
3805
  if (array)
3813
3806
  {
3820
3813
  {
3821
3814
    Item_result cmp_type= item_cmp_type(left_result_type, args[i]->result_type());
3822
3815
    in_item= cmp_items[(uint)cmp_type];
3823
 
    DBUG_ASSERT(in_item);
 
3816
    assert(in_item);
3824
3817
    if (!(value_added_map & (1 << (uint)cmp_type)))
3825
3818
    {
3826
3819
      in_item->store_value(args[0]);
3841
3834
 
3842
3835
longlong Item_func_bit_or::val_int()
3843
3836
{
3844
 
  DBUG_ASSERT(fixed == 1);
 
3837
  assert(fixed == 1);
3845
3838
  ulonglong arg1= (ulonglong) args[0]->val_int();
3846
3839
  if (args[0]->null_value)
3847
3840
  {
3861
3854
 
3862
3855
longlong Item_func_bit_and::val_int()
3863
3856
{
3864
 
  DBUG_ASSERT(fixed == 1);
 
3857
  assert(fixed == 1);
3865
3858
  ulonglong arg1= (ulonglong) args[0]->val_int();
3866
3859
  if (args[0]->null_value)
3867
3860
  {
3900
3893
bool
3901
3894
Item_cond::fix_fields(THD *thd, Item **ref __attribute__((__unused__)))
3902
3895
{
3903
 
  DBUG_ASSERT(fixed == 0);
 
3896
  assert(fixed == 0);
3904
3897
  List_iterator<Item> li(list);
3905
3898
  Item *item;
3906
3899
  void *orig_thd_marker= thd->thd_marker;
4236
4229
 
4237
4230
longlong Item_cond_and::val_int()
4238
4231
{
4239
 
  DBUG_ASSERT(fixed == 1);
 
4232
  assert(fixed == 1);
4240
4233
  List_iterator_fast<Item> li(list);
4241
4234
  Item *item;
4242
4235
  null_value= 0;
4254
4247
 
4255
4248
longlong Item_cond_or::val_int()
4256
4249
{
4257
 
  DBUG_ASSERT(fixed == 1);
 
4250
  assert(fixed == 1);
4258
4251
  List_iterator_fast<Item> li(list);
4259
4252
  Item *item;
4260
4253
  null_value=0;
4315
4308
 
4316
4309
longlong Item_func_isnull::val_int()
4317
4310
{
4318
 
  DBUG_ASSERT(fixed == 1);
 
4311
  assert(fixed == 1);
4319
4312
  /*
4320
4313
    Handle optimization if the argument can't be null
4321
4314
    This has to be here because of the test in update_used_tables().
4327
4320
 
4328
4321
longlong Item_is_not_null_test::val_int()
4329
4322
{
4330
 
  DBUG_ASSERT(fixed == 1);
4331
 
  DBUG_ENTER("Item_is_not_null_test::val_int");
 
4323
  assert(fixed == 1);
4332
4324
  if (!used_tables_cache && !with_subselect)
4333
4325
  {
4334
4326
    owner->was_null|= (!cached_value);
4335
 
    DBUG_PRINT("info", ("cached: %ld", (long) cached_value));
4336
 
    DBUG_RETURN(cached_value);
 
4327
    return(cached_value);
4337
4328
  }
4338
4329
  if (args[0]->is_null())
4339
4330
  {
4340
 
    DBUG_PRINT("info", ("null"));
4341
4331
    owner->was_null|= 1;
4342
 
    DBUG_RETURN(0);
 
4332
    return(0);
4343
4333
  }
4344
4334
  else
4345
 
    DBUG_RETURN(1);
 
4335
    return(1);
4346
4336
}
4347
4337
 
4348
4338
/**
4369
4359
 
4370
4360
longlong Item_func_isnotnull::val_int()
4371
4361
{
4372
 
  DBUG_ASSERT(fixed == 1);
 
4362
  assert(fixed == 1);
4373
4363
  return args[0]->is_null() ? 0 : 1;
4374
4364
}
4375
4365
 
4384
4374
 
4385
4375
longlong Item_func_like::val_int()
4386
4376
{
4387
 
  DBUG_ASSERT(fixed == 1);
 
4377
  assert(fixed == 1);
4388
4378
  String* res = args[0]->val_str(&tmp_value1);
4389
4379
  if (args[0]->null_value)
4390
4380
  {
4432
4422
 
4433
4423
bool Item_func_like::fix_fields(THD *thd, Item **ref)
4434
4424
{
4435
 
  DBUG_ASSERT(fixed == 0);
 
4425
  assert(fixed == 0);
4436
4426
  if (Item_bool_func2::fix_fields(thd, ref) ||
4437
4427
      escape_item->fix_fields(thd, &escape_item))
4438
4428
    return true;
4525
4515
      {
4526
4516
        pattern     = first + 1;
4527
4517
        pattern_len = (int) len - 2;
4528
 
        DBUG_PRINT("info", ("Initializing pattern: '%s'", first));
4529
4518
        int *suff = (int*) thd->alloc((int) (sizeof(int)*
4530
4519
                                      ((pattern_len + 1)*2+
4531
4520
                                      alphabet_size)));
4533
4522
        bmBc      = bmGs + pattern_len + 1;
4534
4523
        turboBM_compute_good_suffix_shifts(suff);
4535
4524
        turboBM_compute_bad_character_shifts();
4536
 
        DBUG_PRINT("info",("done"));
4537
4525
      }
4538
4526
    }
4539
4527
  }
4784
4772
 
4785
4773
longlong Item_cond_xor::val_int()
4786
4774
{
4787
 
  DBUG_ASSERT(fixed == 1);
 
4775
  assert(fixed == 1);
4788
4776
  List_iterator<Item> li(list);
4789
4777
  Item *item;
4790
4778
  int result=0; 
4940
4928
*/
4941
4929
Item *Item_bool_rowready_func2::negated_item()
4942
4930
{
4943
 
  DBUG_ASSERT(0);
 
4931
  assert(0);
4944
4932
  return 0;
4945
4933
}
4946
4934