Mercurial > hg > octave-nkf

comparison src/ov-typeinfo.cc @ 9223:902a4597dce8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
use Array<void *> in ov-typeinfo.h
author Jaroslav Hajek <highegg@gmail.com>
date Wed, 20 May 2009 14:13:31 +0200
parents 612918b993a0
children cd96d29c5efa
comparison
equal deleted inserted replaced
9222:7bd406e12e4d 9223:902a4597dce8
38 38
39 #include <Array.h> 39 #include <Array.h>
40 #include <Array2.h> 40 #include <Array2.h>
41 #include <Array3.h> 41 #include <Array3.h>
42 42
43 #include <Array.cc>
44
45 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::unary_op_fcn);
46 INSTANTIATE_ARRAY (octave_value_typeinfo::unary_op_fcn, );
47 template class Array2<octave_value_typeinfo::unary_op_fcn>;
48
49 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::non_const_unary_op_fcn);
50 INSTANTIATE_ARRAY (octave_value_typeinfo::non_const_unary_op_fcn, );
51 template class Array2<octave_value_typeinfo::non_const_unary_op_fcn>;
52
53 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::binary_op_fcn);
54 INSTANTIATE_ARRAY (octave_value_typeinfo::binary_op_fcn, );
55 template class Array2<octave_value_typeinfo::binary_op_fcn>;
56 template class Array3<octave_value_typeinfo::binary_op_fcn>;
57
58 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::cat_op_fcn);
59 INSTANTIATE_ARRAY (octave_value_typeinfo::cat_op_fcn, );
60 template class Array2<octave_value_typeinfo::cat_op_fcn>;
61
62 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::assign_op_fcn);
63 INSTANTIATE_ARRAY (octave_value_typeinfo::assign_op_fcn, );
64 template class Array2<octave_value_typeinfo::assign_op_fcn>;
65 template class Array3<octave_value_typeinfo::assign_op_fcn>;
66
67 NO_INSTANTIATE_ARRAY_SORT (octave_value_typeinfo::assignany_op_fcn);
68 INSTANTIATE_ARRAY (octave_value_typeinfo::assignany_op_fcn, );
69 template class Array2<octave_value_typeinfo::assignany_op_fcn>;
70
71 NO_INSTANTIATE_ARRAY_SORT (octave_base_value::type_conv_fcn);
72 INSTANTIATE_ARRAY (octave_base_value::type_conv_fcn, );
73 template class Array2<octave_base_value::type_conv_fcn>;
74
75 bool 43 bool
76 octave_value_typeinfo::instance_ok (void) 44 octave_value_typeinfo::instance_ok (void)
77 { 45 {
78 bool retval = true; 46 bool retval = true;
79 if (! instance) 47 if (! instance)
227 195
228 types.resize (len, std::string ()); 196 types.resize (len, std::string ());
229 197
230 vals.resize (len, octave_value ()); 198 vals.resize (len, octave_value ());
231 199
232 unary_ops.resize (static_cast<int> (octave_value::num_unary_ops), 200 unary_ops.resize (static_cast<int> (octave_value::num_unary_ops), len, 0);
233 len, static_cast<octave_value_typeinfo::unary_op_fcn> (0));
234 201
235 non_const_unary_ops.resize 202 non_const_unary_ops.resize
236 (static_cast<int> (octave_value::num_unary_ops), 203 (static_cast<int> (octave_value::num_unary_ops), len, 0);
237 len, static_cast<octave_value_typeinfo::non_const_unary_op_fcn> (0));
238 204
239 binary_ops.resize (static_cast<int> (octave_value::num_binary_ops), 205 binary_ops.resize (static_cast<int> (octave_value::num_binary_ops),
240 len, len, static_cast<octave_value_typeinfo::binary_op_fcn> (0)); 206 len, len, 0);
241 207
242 compound_binary_ops.resize (static_cast<int> (octave_value::num_compound_binary_ops), 208 compound_binary_ops.resize (static_cast<int> (octave_value::num_compound_binary_ops),
243 len, len, static_cast<octave_value_typeinfo::binary_op_fcn> (0)); 209 len, len, 0);
244 210
245 cat_ops.resize (len, len, static_cast<octave_value_typeinfo::cat_op_fcn> (0)); 211 cat_ops.resize (len, len, 0);
246 212
247 assign_ops.resize (static_cast<int> (octave_value::num_assign_ops), 213 assign_ops.resize (static_cast<int> (octave_value::num_assign_ops), len, len, 0);
248 len, len, static_cast<octave_value_typeinfo::assign_op_fcn> (0)); 214
249 215 assignany_ops.resize (static_cast<int> (octave_value::num_assign_ops), len, 0);
250 assignany_ops.resize (static_cast<int> (octave_value::num_assign_ops),
251 len, static_cast<octave_value_typeinfo::assignany_op_fcn> (0));
252 216
253 pref_assign_conv.resize (len, len, -1); 217 pref_assign_conv.resize (len, len, -1);
254 218
255 type_conv_ops.resize (len, len, static_cast<octave_base_value::type_conv_fcn> (0)); 219 type_conv_ops.resize (len, len, 0);
256 220
257 widening_ops.resize (len, len, static_cast<octave_base_value::type_conv_fcn> (0)); 221 widening_ops.resize (len, len, 0);
258 } 222 }
259 223
260 types (i) = t_name; 224 types (i) = t_name;
261 225
262 vals (i) = val; 226 vals (i) = val;
276 240
277 warning ("duplicate unary operator `%s' for class dispatch", 241 warning ("duplicate unary operator `%s' for class dispatch",
278 op_name.c_str ()); 242 op_name.c_str ());
279 } 243 }
280 244
281 unary_class_ops.checkelem (static_cast<int> (op)) = f; 245 unary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
282 246
283 return false; 247 return false;
284 } 248 }
285 249
286 bool 250 bool
294 258
295 warning ("duplicate unary operator `%s' for type `%s'", 259 warning ("duplicate unary operator `%s' for type `%s'",
296 op_name.c_str (), type_name.c_str ()); 260 op_name.c_str (), type_name.c_str ());
297 } 261 }
298 262
299 unary_ops.checkelem (static_cast<int> (op), t) = f; 263 unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
300 264
301 return false; 265 return false;
302 } 266 }
303 267
304 bool 268 bool
312 276
313 warning ("duplicate unary operator `%s' for type `%s'", 277 warning ("duplicate unary operator `%s' for type `%s'",
314 op_name.c_str (), type_name.c_str ()); 278 op_name.c_str (), type_name.c_str ());
315 } 279 }
316 280
317 non_const_unary_ops.checkelem (static_cast<int> (op), t) = f; 281 non_const_unary_ops.checkelem (static_cast<int> (op), t) = reinterpret_cast<void *> (f);
318 282
319 return false; 283 return false;
320 } 284 }
321 285
322 bool 286 bool
329 293
330 warning ("duplicate binary operator `%s' for class dispatch", 294 warning ("duplicate binary operator `%s' for class dispatch",
331 op_name.c_str ()); 295 op_name.c_str ());
332 } 296 }
333 297
334 binary_class_ops.checkelem (static_cast<int> (op)) = f; 298 binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
335 299
336 return false; 300 return false;
337 } 301 }
338 302
339 bool 303 bool
349 313
350 warning ("duplicate binary operator `%s' for types `%s' and `%s'", 314 warning ("duplicate binary operator `%s' for types `%s' and `%s'",
351 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); 315 op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
352 } 316 }
353 317
354 binary_ops.checkelem (static_cast<int> (op), t1, t2) = f; 318 binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f);
355 319
356 return false; 320 return false;
357 } 321 }
358 322
359 bool 323 bool
366 330
367 warning ("duplicate compound binary operator `%s' for class dispatch", 331 warning ("duplicate compound binary operator `%s' for class dispatch",
368 op_name.c_str ()); 332 op_name.c_str ());
369 } 333 }
370 334
371 compound_binary_class_ops.checkelem (static_cast<int> (op)) = f; 335 compound_binary_class_ops.checkelem (static_cast<int> (op)) = reinterpret_cast<void *> (f);
372 336
373 return false; 337 return false;
374 } 338 }
375 339
376 bool 340 bool
386 350
387 warning ("duplicate compound binary operator `%s' for types `%s' and `%s'", 351 warning ("duplicate compound binary operator `%s' for types `%s' and `%s'",
388 op_name.c_str (), t1_name.c_str (), t1_name.c_str ()); 352 op_name.c_str (), t1_name.c_str (), t1_name.c_str ());
389 } 353 }
390 354
391 compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) = f; 355 compound_binary_ops.checkelem (static_cast<int> (op), t1, t2) = reinterpret_cast<void *> (f);
392 356
393 return false; 357 return false;
394 } 358 }
395 359
396 bool 360 bool
403 367
404 warning ("duplicate concatenation operator for types `%s' and `%s'", 368 warning ("duplicate concatenation operator for types `%s' and `%s'",
405 t1_name.c_str (), t1_name.c_str ()); 369 t1_name.c_str (), t1_name.c_str ());
406 } 370 }
407 371
408 cat_ops.checkelem (t1, t2) = f; 372 cat_ops.checkelem (t1, t2) = reinterpret_cast<void *> (f);
409 373
410 return false; 374 return false;
411 } 375 }
412 376
413 bool 377 bool
423 387
424 warning ("duplicate assignment operator `%s' for types `%s' and `%s'", 388 warning ("duplicate assignment operator `%s' for types `%s' and `%s'",
425 op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ()); 389 op_name.c_str (), t_lhs_name.c_str (), t_rhs_name.c_str ());
426 } 390 }
427 391
428 assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) = f; 392 assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs) = reinterpret_cast<void *> (f);
429 393
430 return false; 394 return false;
431 } 395 }
432 396
433 bool 397 bool
441 405
442 warning ("duplicate assignment operator `%s' for types `%s'", 406 warning ("duplicate assignment operator `%s' for types `%s'",
443 op_name.c_str (), t_lhs_name.c_str ()); 407 op_name.c_str (), t_lhs_name.c_str ());
444 } 408 }
445 409
446 assignany_ops.checkelem (static_cast<int> (op), t_lhs) = f; 410 assignany_ops.checkelem (static_cast<int> (op), t_lhs) = reinterpret_cast<void *> (f);
447 411
448 return false; 412 return false;
449 } 413 }
450 414
451 bool 415 bool
477 441
478 warning ("overriding type conversion op for `%s' to `%s'", 442 warning ("overriding type conversion op for `%s' to `%s'",
479 t_name.c_str (), t_result_name.c_str ()); 443 t_name.c_str (), t_result_name.c_str ());
480 } 444 }
481 445
482 type_conv_ops.checkelem (t, t_result) = f; 446 type_conv_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
483 447
484 return false; 448 return false;
485 } 449 }
486 450
487 bool 451 bool
495 459
496 warning ("overriding widening op for `%s' to `%s'", 460 warning ("overriding widening op for `%s' to `%s'",
497 t_name.c_str (), t_result_name.c_str ()); 461 t_name.c_str (), t_result_name.c_str ());
498 } 462 }
499 463
500 widening_ops.checkelem (t, t_result) = f; 464 widening_ops.checkelem (t, t_result) = reinterpret_cast<void *> (f);
501 465
502 return false; 466 return false;
503 } 467 }
504 468
505 octave_value 469 octave_value
521 } 485 }
522 486
523 octave_value_typeinfo::unary_class_op_fcn 487 octave_value_typeinfo::unary_class_op_fcn
524 octave_value_typeinfo::do_lookup_unary_class_op (octave_value::unary_op op) 488 octave_value_typeinfo::do_lookup_unary_class_op (octave_value::unary_op op)
525 { 489 {
526 return unary_class_ops.checkelem (static_cast<int> (op)); 490 void *f = unary_class_ops.checkelem (static_cast<int> (op));
491 return reinterpret_cast<octave_value_typeinfo::unary_class_op_fcn> (f);
527 } 492 }
528 493
529 octave_value_typeinfo::unary_op_fcn 494 octave_value_typeinfo::unary_op_fcn
530 octave_value_typeinfo::do_lookup_unary_op (octave_value::unary_op op, int t) 495 octave_value_typeinfo::do_lookup_unary_op (octave_value::unary_op op, int t)
531 { 496 {
532 return unary_ops.checkelem (static_cast<int> (op), t); 497 void *f = unary_ops.checkelem (static_cast<int> (op), t);
498 return reinterpret_cast<octave_value_typeinfo::unary_op_fcn> (f);
533 } 499 }
534 500
535 octave_value_typeinfo::non_const_unary_op_fcn 501 octave_value_typeinfo::non_const_unary_op_fcn
536 octave_value_typeinfo::do_lookup_non_const_unary_op 502 octave_value_typeinfo::do_lookup_non_const_unary_op
537 (octave_value::unary_op op, int t) 503 (octave_value::unary_op op, int t)
538 { 504 {
539 return non_const_unary_ops.checkelem (static_cast<int> (op), t); 505 void *f = non_const_unary_ops.checkelem (static_cast<int> (op), t);
506 return reinterpret_cast<octave_value_typeinfo::non_const_unary_op_fcn> (f);
540 } 507 }
541 508
542 octave_value_typeinfo::binary_class_op_fcn 509 octave_value_typeinfo::binary_class_op_fcn
543 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::binary_op op) 510 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::binary_op op)
544 { 511 {
545 return binary_class_ops.checkelem (static_cast<int> (op)); 512 void *f = binary_class_ops.checkelem (static_cast<int> (op));
513 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f);
546 } 514 }
547 515
548 octave_value_typeinfo::binary_op_fcn 516 octave_value_typeinfo::binary_op_fcn
549 octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op, 517 octave_value_typeinfo::do_lookup_binary_op (octave_value::binary_op op,
550 int t1, int t2) 518 int t1, int t2)
551 { 519 {
552 return binary_ops.checkelem (static_cast<int> (op), t1, t2); 520 void *f = binary_ops.checkelem (static_cast<int> (op), t1, t2);
521 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f);
553 } 522 }
554 523
555 octave_value_typeinfo::binary_class_op_fcn 524 octave_value_typeinfo::binary_class_op_fcn
556 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::compound_binary_op op) 525 octave_value_typeinfo::do_lookup_binary_class_op (octave_value::compound_binary_op op)
557 { 526 {
558 return compound_binary_class_ops.checkelem (static_cast<int> (op)); 527 void *f = compound_binary_class_ops.checkelem (static_cast<int> (op));
528 return reinterpret_cast<octave_value_typeinfo::binary_class_op_fcn> (f);
559 } 529 }
560 530
561 octave_value_typeinfo::binary_op_fcn 531 octave_value_typeinfo::binary_op_fcn
562 octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op, 532 octave_value_typeinfo::do_lookup_binary_op (octave_value::compound_binary_op op,
563 int t1, int t2) 533 int t1, int t2)
564 { 534 {
565 return compound_binary_ops.checkelem (static_cast<int> (op), t1, t2); 535 void *f = compound_binary_ops.checkelem (static_cast<int> (op), t1, t2);
536 return reinterpret_cast<octave_value_typeinfo::binary_op_fcn> (f);
566 } 537 }
567 538
568 octave_value_typeinfo::cat_op_fcn 539 octave_value_typeinfo::cat_op_fcn
569 octave_value_typeinfo::do_lookup_cat_op (int t1, int t2) 540 octave_value_typeinfo::do_lookup_cat_op (int t1, int t2)
570 { 541 {
571 return cat_ops.checkelem (t1, t2); 542 void *f = cat_ops.checkelem (t1, t2);
543 return reinterpret_cast<octave_value_typeinfo::cat_op_fcn> (f);
572 } 544 }
573 545
574 octave_value_typeinfo::assign_op_fcn 546 octave_value_typeinfo::assign_op_fcn
575 octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op, 547 octave_value_typeinfo::do_lookup_assign_op (octave_value::assign_op op,
576 int t_lhs, int t_rhs) 548 int t_lhs, int t_rhs)
577 { 549 {
578 return assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs); 550 void *f = assign_ops.checkelem (static_cast<int> (op), t_lhs, t_rhs);
551 return reinterpret_cast<octave_value_typeinfo::assign_op_fcn> (f);
579 } 552 }
580 553
581 octave_value_typeinfo::assignany_op_fcn 554 octave_value_typeinfo::assignany_op_fcn
582 octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op, 555 octave_value_typeinfo::do_lookup_assignany_op (octave_value::assign_op op,
583 int t_lhs) 556 int t_lhs)
584 { 557 {
585 return assignany_ops.checkelem (static_cast<int> (op), t_lhs); 558 void *f = assignany_ops.checkelem (static_cast<int> (op), t_lhs);
559 return reinterpret_cast<octave_value_typeinfo::assignany_op_fcn> (f);
586 } 560 }
587 561
588 int 562 int
589 octave_value_typeinfo::do_lookup_pref_assign_conv (int t_lhs, int t_rhs) 563 octave_value_typeinfo::do_lookup_pref_assign_conv (int t_lhs, int t_rhs)
590 { 564 {
592 } 566 }
593 567
594 octave_base_value::type_conv_fcn 568 octave_base_value::type_conv_fcn
595 octave_value_typeinfo::do_lookup_type_conv_op (int t, int t_result) 569 octave_value_typeinfo::do_lookup_type_conv_op (int t, int t_result)
596 { 570 {
597 return type_conv_ops.checkelem (t, t_result); 571 void *f = type_conv_ops.checkelem (t, t_result);
572 return reinterpret_cast<octave_base_value::type_conv_fcn> (f);
598 } 573 }
599 574
600 octave_base_value::type_conv_fcn 575 octave_base_value::type_conv_fcn
601 octave_value_typeinfo::do_lookup_widening_op (int t, int t_result) 576 octave_value_typeinfo::do_lookup_widening_op (int t, int t_result)
602 { 577 {
603 return widening_ops.checkelem (t, t_result); 578 void *f = widening_ops.checkelem (t, t_result);
579 return reinterpret_cast<octave_base_value::type_conv_fcn> (f);
604 } 580 }
605 581
606 string_vector 582 string_vector
607 octave_value_typeinfo::do_installed_type_names (void) 583 octave_value_typeinfo::do_installed_type_names (void)
608 { 584 {