gcc/testsuite/g++.dg/torture/pr31863.C

   1 /* { dg-do link } */
   2 /* { dg-timeout-factor 2.0 } */
   3 /* { dg-skip-if "Program too big" { "avr-*-*" } { "*" } { "" } } */
   4
   5 namespace Loki
   6 {
   7     class NullType {};
   8     template <class T, class U>
   9     struct Typelist
  10     {
  11        typedef T Head;
  12        typedef U Tail;
  13     };
  14
  15
  16
  17     namespace TL
  18     {
  19         template
  20         <
  21                 typename T1 = NullType, typename T2 = NullType, typename T3 =
  22 NullType,
  23                 typename T4 = NullType, typename T5 = NullType, typename T6 =
  24 NullType,
  25                 typename T7 = NullType, typename T8 = NullType, typename T9 =
  26 NullType,
  27                 typename T10 = NullType, typename T11 = NullType, typename T12
  28 = NullType,
  29                 typename T13 = NullType, typename T14 = NullType, typename T15
  30 = NullType,
  31                 typename T16 = NullType, typename T17 = NullType, typename T18
  32 = NullType,
  33                 typename T19 = NullType, typename T20 = NullType, typename T21
  34 = NullType,
  35                 typename T22 = NullType, typename T23 = NullType, typename T24
  36 = NullType,
  37                 typename T25 = NullType, typename T26 = NullType, typename T27
  38 = NullType,
  39                 typename T28 = NullType, typename T29 = NullType, typename T30
  40 = NullType,
  41                 typename T31 = NullType, typename T32 = NullType, typename T33
  42 = NullType,
  43                 typename T34 = NullType, typename T35 = NullType, typename T36
  44 = NullType,
  45                 typename T37 = NullType, typename T38 = NullType, typename T39
  46 = NullType,
  47                 typename T40 = NullType
  48         >
  49         struct MakeTypelist
  50         {
  51         private:
  52             typedef typename MakeTypelist
  53             <
  54                 T2 , T3 , T4 ,
  55                 T5 , T6 , T7 ,
  56                 T8 , T9 , T10,
  57                 T11, T12, T13,
  58                 T14, T15, T16,
  59                 T17, T18, T19,
  60                 T20, T21, T22,
  61                 T23, T24, T25,
  62                 T26, T27, T28,
  63                 T29, T30, T31,
  64                 T32, T33, T34,
  65                 T35, T36, T37,
  66                 T38, T39, T40
  67             >
  68             ::Result TailResult;
  69
  70         public:
  71             typedef Typelist<T1, TailResult> Result;
  72         };
  73
  74         template<>
  75         struct MakeTypelist<>
  76         {
  77             typedef NullType Result;
  78         };
  79
  80     }
  81 }
  82 template <class Key>
  83 class Factory;
  84
  85 template <class Key, bool iW>
  86 struct Context
  87 {
  88     typedef Key KeyType;
  89     enum
  90     {
  91         isWrite = iW
  92     };
  93 };
  94
  95 namespace detail
  96 {
  97
  98 template <class Key, bool isWrite>
  99 class CreatorUnitBaseImpl
 100 {
 101 public:
 102     typedef Context<Key, isWrite> Context_;
 103 private:
 104     typedef void*(CreatorUnitBaseImpl::*CreateFun)(Context_&, unsigned&, const
 105 Key&);
 106     CreateFun createFun_;
 107
 108 protected:
 109     virtual void* createUninitialized () = 0;
 110     template <class Value>
 111     void* createImpl (Context_& ctx, unsigned& ver, const Key& k)
 112     {
 113         return createUninitialized();
 114     }
 115 private:
 116     CreatorUnitBaseImpl();
 117 public:
 118     template <class Value>
 119     CreatorUnitBaseImpl (Value*) :
 120         createFun_( &CreatorUnitBaseImpl::template createImpl<Value> )
 121     {
 122     }
 123
 124     virtual ~CreatorUnitBaseImpl () {}
 125
 126     CreatorUnitBaseImpl(const CreatorUnitBaseImpl& s)
 127         : createFun_(s.createFun_)
 128     {
 129     }
 130
 131     CreatorUnitBaseImpl& operator=(const CreatorUnitBaseImpl& s)
 132     {
 133         createFun_ = s.createFun_;
 134         return *this;
 135     }
 136     void* create (Context_& ctx, unsigned& ver, const Key& k)
 137     {
 138         return (this->*createFun_)(ctx, ver, k);
 139     }
 140 };
 141
 142 template <class Key>
 143 class Creator : protected CreatorUnitBaseImpl<Key, true>, protected
 144 CreatorUnitBaseImpl<Key, false>
 145 {
 146 public:
 147     typedef void* (*CreatorFun) ();
 148
 149 private:
 150     CreatorFun fun_;
 151 protected:
 152     virtual void* createUninitialized ()
 153     {
 154         if (fun_)
 155             return (*fun_)();
 156         return 0;
 157     }
 158 private:
 159     Creator ();
 160 public:
 161     template <class Value>
 162     Creator (CreatorFun f, Value*) :
 163         CreatorUnitBaseImpl<Key, true>((Value*)0),
 164         CreatorUnitBaseImpl<Key, false>((Value*)0),
 165         fun_(f)
 166     {
 167     }
 168
 169     Creator(const Creator& s) :
 170         CreatorUnitBaseImpl<Key, true>(s),
 171         CreatorUnitBaseImpl<Key, false>(s),
 172         fun_(s.fun_)
 173     {
 174
 175     }
 176
 177     Creator& operator=(const Creator& s)
 178     {
 179         CreatorUnitBaseImpl<Key, true>::operator=(s);
 180         CreatorUnitBaseImpl<Key, false>::operator=(s);
 181         fun_ = s.fun_;
 182         return *this;
 183     }
 184
 185     virtual ~Creator ()
 186     {
 187     }
 188
 189     template <class Context>
 190     void* createObject (Context& ctx, unsigned& ver, const Key& k)
 191     {
 192         void* r = CreatorUnitBaseImpl<Key, Context::isWrite>::create(ctx, ver,
 193 k);
 194         return r;
 195     }
 196 };
 197
 198 }
 199
 200 template <class Key>
 201 class Factory
 202 {
 203 public:
 204     typedef Key KeyType;
 205     typedef void* (*CreatorFun) ();
 206     typedef detail::Creator<Key> Creator;
 207 public:
 208     Factory () {}
 209     ~Factory () {}
 210
 211     template <class Value>
 212     bool registerCreator (const Key& k, CreatorFun fun)
 213     {
 214         return true;
 215     }
 216     template <class Context>
 217     void* createObject (const Key& k, Context& ctx, unsigned& ver)
 218     {
 219         return 0;
 220     }
 221 };
 222
 223 template <class Key, class Base, Key key>
 224 struct ClassSpec
 225 {
 226     typedef Key KeyType;
 227     typedef Base BaseType;
 228     enum {KeyValue = key};
 229 };
 230
 231 template <class Key, class T>
 232 class Serializer;
 233
 234 template <class Key, class Base, Key key>
 235 class Serializer<Key, ClassSpec <Key, Base, key> >
 236     : public virtual Factory<Key>
 237 {
 238     typedef Key KeyType;
 239     typedef Base BaseType;
 240     enum {KeyValue = key};
 241     typedef Factory<Key> Inherited;
 242     typedef Serializer<Key, ClassSpec< Key, Base, key > > SelfType;
 243
 244     static void* create ()
 245     {
 246         return (void*) (new BaseType);
 247     }
 248 public:
 249     Serializer()
 250     {
 251         Inherited::template registerCreator<BaseType>(
 252                 KeyValue,
 253                 &SelfType::create);
 254     }
 255 };
 256
 257 template <class Key, class Head>
 258 class Serializer<Key, Loki::Typelist<Head, Loki::NullType> >:
 259     public Serializer<Key, Head>
 260 {
 261 };
 262
 263 template <class Key, class Head, class Tail>
 264 class Serializer<Key, Loki::Typelist<Head, Tail> >:
 265     public virtual Serializer<Key, Head>,
 266     public virtual Serializer<Key, Tail>
 267 {
 268 };
 269
 270 template <class Key>
 271 class Serializer<Key, Loki::NullType> : public virtual Factory<Key>
 272 {
 273 };
 274
 275
 276
 277
 278 typedef unsigned KeyType;
 279
 280
 281
 282 typedef Factory<KeyType> FactoryType;
 283
 284 typedef KeyType Key;
 285
 286 struct A001
 287 {
 288     template <class Context>
 289     bool serialize(Context& ctx, unsigned& ver)
 290     {
 291         return true;
 292     }
 293     static Key classId() { return 1; }
 294     static const char* className () {return "A001";}
 295 };
 296
 297 struct A002
 298 {
 299     template <class Context>
 300     bool serialize(Context& ctx, unsigned& ver)
 301     {
 302         return true;
 303     }
 304     static Key classId() { return 2; }
 305     static const char* className () {return "A002";}
 306 };
 307
 308 struct A003
 309 {
 310     template <class Context>
 311     bool serialize(Context& ctx, unsigned& ver)
 312     {
 313         return true;
 314     }
 315     static Key classId() { return 3; }
 316     static const char* className () {return "A003";}
 317 };
 318
 319 struct A004
 320 {
 321     template <class Context>
 322     bool serialize(Context& ctx, unsigned& ver)
 323     {
 324         return true;
 325     }
 326     static Key classId() { return 4; }
 327     static const char* className () {return "A004";}
 328 };
 329
 330 struct A005
 331 {
 332     template <class Context>
 333     bool serialize(Context& ctx, unsigned& ver)
 334     {
 335         return true;
 336     }
 337     static Key classId() { return 5; }
 338     static const char* className () {return "A005";}
 339 };
 340
 341 struct A006
 342 {
 343     template <class Context>
 344     bool serialize(Context& ctx, unsigned& ver)
 345     {
 346         return true;
 347     }
 348     static Key classId() { return 6; }
 349     static const char* className () {return "A006";}
 350 };
 351
 352 struct A007
 353 {
 354     template <class Context>
 355     bool serialize(Context& ctx, unsigned& ver)
 356     {
 357         return true;
 358     }
 359     static Key classId() { return 7; }
 360     static const char* className () {return "A007";}
 361 };
 362
 363 struct A008
 364 {
 365     template <class Context>
 366     bool serialize(Context& ctx, unsigned& ver)
 367     {
 368         return true;
 369     }
 370     static Key classId() { return 8; }
 371     static const char* className () {return "A008";}
 372 };
 373
 374 struct A009
 375 {
 376     template <class Context>
 377     bool serialize(Context& ctx, unsigned& ver)
 378     {
 379         return true;
 380     }
 381     static Key classId() { return 9; }
 382     static const char* className () {return "A009";}
 383 };
 384
 385 struct A010
 386 {
 387     template <class Context>
 388     bool serialize(Context& ctx, unsigned& ver)
 389     {
 390         return true;
 391     }
 392     static Key classId() { return 10; }
 393     static const char* className () {return "A010";}
 394 };
 395
 396 struct A011
 397 {
 398     template <class Context>
 399     bool serialize(Context& ctx, unsigned& ver)
 400     {
 401         return true;
 402     }
 403     static Key classId() { return 11; }
 404     static const char* className () {return "A011";}
 405 };
 406
 407 struct A012
 408 {
 409     template <class Context>
 410     bool serialize(Context& ctx, unsigned& ver)
 411     {
 412         return true;
 413     }
 414     static Key classId() { return 12; }
 415     static const char* className () {return "A012";}
 416 };
 417
 418 struct A013
 419 {
 420     template <class Context>
 421     bool serialize(Context& ctx, unsigned& ver)
 422     {
 423         return true;
 424     }
 425     static Key classId() { return 13; }
 426     static const char* className () {return "A013";}
 427 };
 428
 429 struct A014
 430 {
 431     template <class Context>
 432     bool serialize(Context& ctx, unsigned& ver)
 433     {
 434         return true;
 435     }
 436     static Key classId() { return 14; }
 437     static const char* className () {return "A014";}
 438 };
 439
 440 struct A015
 441 {
 442     template <class Context>
 443     bool serialize(Context& ctx, unsigned& ver)
 444     {
 445         return true;
 446     }
 447     static Key classId() { return 15; }
 448     static const char* className () {return "A015";}
 449 };
 450
 451 struct A016
 452 {
 453     template <class Context>
 454     bool serialize(Context& ctx, unsigned& ver)
 455     {
 456         return true;
 457     }
 458     static Key classId() { return 16; }
 459     static const char* className () {return "A016";}
 460 };
 461
 462 struct A017
 463 {
 464     template <class Context>
 465     bool serialize(Context& ctx, unsigned& ver)
 466     {
 467         return true;
 468     }
 469     static Key classId() { return 17; }
 470     static const char* className () {return "A017";}
 471 };
 472
 473 struct A018
 474 {
 475     template <class Context>
 476     bool serialize(Context& ctx, unsigned& ver)
 477     {
 478         return true;
 479     }
 480     static Key classId() { return 18; }
 481     static const char* className () {return "A018";}
 482 };
 483
 484 struct A019
 485 {
 486     template <class Context>
 487     bool serialize(Context& ctx, unsigned& ver)
 488     {
 489         return true;
 490     }
 491     static Key classId() { return 19; }
 492     static const char* className () {return "A019";}
 493 };
 494
 495 struct A020
 496 {
 497     template <class Context>
 498     bool serialize(Context& ctx, unsigned& ver)
 499     {
 500         return true;
 501     }
 502     static Key classId() { return 20; }
 503     static const char* className () {return "A020";}
 504 };
 505
 506 struct A021
 507 {
 508     template <class Context>
 509     bool serialize(Context& ctx, unsigned& ver)
 510     {
 511         return true;
 512     }
 513     static Key classId() { return 21; }
 514     static const char* className () {return "A021";}
 515 };
 516
 517 struct A022
 518 {
 519     template <class Context>
 520     bool serialize(Context& ctx, unsigned& ver)
 521     {
 522         return true;
 523     }
 524     static Key classId() { return 22; }
 525     static const char* className () {return "A022";}
 526 };
 527
 528 struct A023
 529 {
 530     template <class Context>
 531     bool serialize(Context& ctx, unsigned& ver)
 532     {
 533         return true;
 534     }
 535     static Key classId() { return 23; }
 536     static const char* className () {return "A023";}
 537 };
 538
 539 struct A024
 540 {
 541     template <class Context>
 542     bool serialize(Context& ctx, unsigned& ver)
 543     {
 544         return true;
 545     }
 546     static Key classId() { return 24; }
 547     static const char* className () {return "A024";}
 548 };
 549
 550 struct A025
 551 {
 552     template <class Context>
 553     bool serialize(Context& ctx, unsigned& ver)
 554     {
 555         return true;
 556     }
 557     static Key classId() { return 25; }
 558     static const char* className () {return "A025";}
 559 };
 560
 561 struct A026
 562 {
 563     template <class Context>
 564     bool serialize(Context& ctx, unsigned& ver)
 565     {
 566         return true;
 567     }
 568     static Key classId() { return 26; }
 569     static const char* className () {return "A026";}
 570 };
 571
 572 struct A027
 573 {
 574     template <class Context>
 575     bool serialize(Context& ctx, unsigned& ver)
 576     {
 577         return true;
 578     }
 579     static Key classId() { return 27; }
 580     static const char* className () {return "A027";}
 581 };
 582
 583 struct A028
 584 {
 585     template <class Context>
 586     bool serialize(Context& ctx, unsigned& ver)
 587     {
 588         return true;
 589     }
 590     static Key classId() { return 28; }
 591     static const char* className () {return "A028";}
 592 };
 593
 594 struct A029
 595 {
 596     template <class Context>
 597     bool serialize(Context& ctx, unsigned& ver)
 598     {
 599         return true;
 600     }
 601     static Key classId() { return 29; }
 602     static const char* className () {return "A029";}
 603 };
 604
 605 struct A030
 606 {
 607     template <class Context>
 608     bool serialize(Context& ctx, unsigned& ver)
 609     {
 610         return true;
 611     }
 612     static Key classId() { return 30; }
 613     static const char* className () {return "A030";}
 614 };
 615
 616 struct A031
 617 {
 618     template <class Context>
 619     bool serialize(Context& ctx, unsigned& ver)
 620     {
 621         return true;
 622     }
 623     static Key classId() { return 31; }
 624     static const char* className () {return "A031";}
 625 };
 626
 627 struct A032
 628 {
 629     template <class Context>
 630     bool serialize(Context& ctx, unsigned& ver)
 631     {
 632         return true;
 633     }
 634     static Key classId() { return 32; }
 635     static const char* className () {return "A032";}
 636 };
 637
 638 struct A033
 639 {
 640     template <class Context>
 641     bool serialize(Context& ctx, unsigned& ver)
 642     {
 643         return true;
 644     }
 645     static Key classId() { return 33; }
 646     static const char* className () {return "A033";}
 647 };
 648
 649 struct A034
 650 {
 651     template <class Context>
 652     bool serialize(Context& ctx, unsigned& ver)
 653     {
 654         return true;
 655     }
 656     static Key classId() { return 34; }
 657     static const char* className () {return "A034";}
 658 };
 659
 660 struct A035
 661 {
 662     template <class Context>
 663     bool serialize(Context& ctx, unsigned& ver)
 664     {
 665         return true;
 666     }
 667     static Key classId() { return 35; }
 668     static const char* className () {return "A035";}
 669 };
 670
 671 struct A036
 672 {
 673     template <class Context>
 674     bool serialize(Context& ctx, unsigned& ver)
 675     {
 676         return true;
 677     }
 678     static Key classId() { return 36; }
 679     static const char* className () {return "A036";}
 680 };
 681
 682 struct A037
 683 {
 684     template <class Context>
 685     bool serialize(Context& ctx, unsigned& ver)
 686     {
 687         return true;
 688     }
 689     static Key classId() { return 37; }
 690     static const char* className () {return "A037";}
 691 };
 692
 693 struct A038
 694 {
 695     template <class Context>
 696     bool serialize(Context& ctx, unsigned& ver)
 697     {
 698         return true;
 699     }
 700     static Key classId() { return 38; }
 701     static const char* className () {return "A038";}
 702 };
 703
 704 struct A039
 705 {
 706     template <class Context>
 707     bool serialize(Context& ctx, unsigned& ver)
 708     {
 709         return true;
 710     }
 711     static Key classId() { return 39; }
 712     static const char* className () {return "A039";}
 713 };
 714
 715 struct A040
 716 {
 717     template <class Context>
 718     bool serialize(Context& ctx, unsigned& ver)
 719     {
 720         return true;
 721     }
 722     static Key classId() { return 40; }
 723     static const char* className () {return "A040";}
 724 };
 725
 726 Factory<Key>& getInstance()
 727 {
 728     static Serializer<Key,
 729         Loki::TL::MakeTypelist<
 730             ClassSpec<Key, A001, 1>,
 731             ClassSpec<Key, A002, 2>,
 732             ClassSpec<Key, A003, 3>,
 733             ClassSpec<Key, A004, 4>,
 734             ClassSpec<Key, A005, 5>,
 735             ClassSpec<Key, A006, 6>,
 736             ClassSpec<Key, A007, 7>,
 737             ClassSpec<Key, A008, 8>,
 738             ClassSpec<Key, A009, 9>,
 739             ClassSpec<Key, A010, 10>,
 740             ClassSpec<Key, A011, 11>,
 741             ClassSpec<Key, A012, 12>,
 742             ClassSpec<Key, A013, 13>,
 743             ClassSpec<Key, A014, 14>,
 744             ClassSpec<Key, A015, 15>,
 745             ClassSpec<Key, A016, 16>,
 746             ClassSpec<Key, A017, 17>,
 747             ClassSpec<Key, A018, 18>,
 748             ClassSpec<Key, A019, 19>,
 749             ClassSpec<Key, A020, 20>,
 750             ClassSpec<Key, A021, 21>,
 751             ClassSpec<Key, A022, 22>,
 752             ClassSpec<Key, A023, 23>,
 753             ClassSpec<Key, A024, 24>,
 754             ClassSpec<Key, A025, 25>,
 755             ClassSpec<Key, A026, 26>,
 756             ClassSpec<Key, A027, 27>,
 757             ClassSpec<Key, A028, 28>,
 758             ClassSpec<Key, A029, 29>,
 759             ClassSpec<Key, A030, 30>,
 760             ClassSpec<Key, A031, 31>,
 761             ClassSpec<Key, A032, 32>,
 762             ClassSpec<Key, A033, 33>,
 763             ClassSpec<Key, A034, 34>,
 764             ClassSpec<Key, A035, 35>,
 765             ClassSpec<Key, A036, 36>,
 766             ClassSpec<Key, A037, 37>,
 767             ClassSpec<Key, A038, 38>,
 768             ClassSpec<Key, A039, 39>,
 769             ClassSpec<Key, A040, 40>
 770         >::Result
 771     > instance;
 772     return instance;
 773 }
 774
 775 int main ()
 776 {
 777     return 0;
 778 }