test/FrontendC++/2008-10-29-WrongOffset.cpp

   1 // RUN: %llvmgxx %s -c -o /dev/null
   2 // PR2917
   3
   4 #include <complex>
   5 template < int Dim, class T, class EngineTag > class Engine;
   6 template < class Subject, class Sub1, bool SV > struct View1Implementation;
   7 template < class LayoutTag, class PatchTag > struct MultiPatch;
   8 template < class LayoutTag, class PatchTag, int Dim2 > struct MultiPatchView;
   9 template < class Engine, class SubDomain > struct NewEngine
  10 {
  11 };
  12 template < class T > class DomainTraits;
  13 template < class DomT, class T, int Dim > struct DomainTraitsDomain
  14 {
  15   typedef DomT NewDomain1_t;
  16 };
  17 template < int Dim > class Interval;
  18 template < int Dim > class Loc;
  19 template < class DT > class DomainBase
  20 {
  21 };
  22
  23 template < int Dim, class DT > class Domain:public DomainBase < DT >
  24 {
  25 };
  26 template < int Dim > struct DomainTraits <Interval < Dim >
  27   >:public DomainTraitsDomain < Interval < Dim >, int, Dim >
  28 {
  29   enum
  30   {
  31     singleValued = false
  32   };
  33 };
  34 template < class T1 > struct NewDomain1
  35 {
  36   typedef typename DomainTraits < T1 >::NewDomain1_t SliceType_t;
  37 };
  38 template < class Domain, class Sub > struct TemporaryNewDomain1
  39 {
  40   typedef typename NewDomain1 < Sub >::SliceType_t SliceType_t;
  41 };
  42 template < int Dim > class Interval:public Domain < Dim,
  43   DomainTraits < Interval < Dim > > >
  44 {
  45 };
  46 template < int Dim > class GuardLayers
  47 {
  48 };
  49 template < class T > class Observer
  50 {
  51 };
  52
  53 template < class T > class Observable
  54 {
  55 private:T & observed_m;
  56   int count_m;
  57 };
  58
  59 class RefCounted
  60 {
  61 };
  62 template < class T > class RefCountedPtr
  63 {
  64 public:typedef RefCountedPtr < T > This_t;
  65   RefCountedPtr (T * const pT):ptr_m (pT)
  66   {
  67   }
  68   inline T *operator-> () const
  69   {
  70   }
  71   T *ptr_m;
  72 };
  73
  74 template < class Dom, class T > class DomainMap
  75 {
  76 };
  77
  78 template < class LayoutTag, int Dim > struct MultiPatchLayoutTraits
  79 {
  80 };
  81 template < int Dim > class LayoutBaseData
  82 {
  83 public:typedef Interval < Dim > Domain_t;
  84   Domain_t domain_m;
  85 };
  86 template < int Dim, class LBD > class LayoutBase
  87 {
  88 public:typedef LayoutBaseData < Dim > LayoutData_t;
  89   typedef typename LayoutData_t::Domain_t Domain_t;
  90   typedef GuardLayers < Dim > GuardLayers_t;
  91   inline const Domain_t & domain () const
  92   {
  93     return pdata_m->domain_m;
  94   }
  95   inline const Domain_t & innerDomain () const
  96   {
  97   }
  98   inline GuardLayers_t externalGuards () const
  99   {
 100   }
 101   RefCountedPtr < LBD > pdata_m;
 102 };
 103 template < class Tag > struct Remote;
 104 struct Brick
 105 {
 106 };
 107 template < class Thing, class Sub > struct View1
 108 {
 109 };
 110 template < int Dim, class T, class LayoutTag,
 111   class PatchTag > struct NewEngine <Engine < Dim, T, MultiPatch < LayoutTag,
 112   PatchTag > >, Interval < Dim > >
 113 {
 114   typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
 115     Dim > >Type_t;
 116 };
 117 template < int Dim, class T, class LayoutTag, class PatchTag,
 118   int Dim2 > struct NewEngine <Engine < Dim, T, MultiPatchView < LayoutTag,
 119   PatchTag, Dim2 > >, Interval < Dim > >
 120 {
 121   typedef Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
 122     Dim2 > >Type_t;
 123 };
 124 template < int Dim, class T, class LayoutTag,
 125   class PatchTag > class Engine < Dim, T, MultiPatch < LayoutTag,
 126   PatchTag > >:public Observer < typename MultiPatchLayoutTraits < LayoutTag,
 127   Dim >::Layout_t >
 128 {
 129 public:typedef MultiPatch < LayoutTag, PatchTag > Tag_t;
 130   typedef Interval < Dim > Domain_t;
 131 };
 132 template < int Dim, class T, class LayoutTag, class PatchTag,
 133   int Dim2 > class Engine < Dim, T, MultiPatchView < LayoutTag, PatchTag,
 134   Dim2 > >
 135 {
 136 public:typedef MultiPatchView < LayoutTag, PatchTag, Dim2 > Tag_t;
 137   typedef Interval < Dim > Domain_t;
 138   typedef T Element_t;
 139   enum
 140   {
 141     dimensions = Dim
 142   };
 143 };
 144 class Full;
 145 template < int Dim, class T = double, class EngineTag = Full > class Vector {
 146 };
 147
 148 template < int Dim > inline Interval < Dim >
 149 shrinkRight (const Interval < Dim > &dom, int s)
 150 {
 151 }
 152
 153 template < int Dim > class GridLayout;
 154 struct GridTag
 155 {
 156 };
 157 template < int Dim > struct MultiPatchLayoutTraits <GridTag, Dim >
 158 {
 159   typedef GridLayout < Dim > Layout_t;
 160 };
 161 template < int Dim > class GridLayoutData:public LayoutBaseData < Dim >,
 162   public RefCounted, public Observable < GridLayoutData < Dim > >
 163 {
 164   typedef int AxisIndex_t;
 165   mutable DomainMap < Interval < 1 >, AxisIndex_t > mapAloc_m[Dim];
 166 };
 167 template < int Dim > class GridLayout:public LayoutBase < Dim,
 168   GridLayoutData < Dim > >, public Observable < GridLayout < Dim > >,
 169   public Observer < GridLayoutData < Dim > >
 170 {
 171 public:typedef GridLayout < Dim > This_t;
 172     GridLayout ();
 173 };
 174 template < class MeshTag, class T, class EngineTag > class Field;
 175 enum CenteringType
 176 {
 177   VertexType, EdgeType, FaceType, CellType
 178 };
 179 enum ContinuityType
 180 {
 181   Continuous = 0, Discontinuous
 182 };
 183 template < int Dim > class Centering
 184 {
 185 public:typedef Loc < Dim > Orientation;
 186   inline int size () const
 187   {
 188   }
 189 };
 190 template < int Dim > const Centering < Dim >
 191 canonicalCentering (const enum CenteringType type,
 192                     const enum ContinuityType discontinuous,
 193                     const int dimension = 0);
 194 template < class Mesh, class T, class EngineTag > class FieldEngine
 195 {
 196 public:enum
 197   {
 198     dimensions = Mesh::dimensions
 199   };
 200   enum
 201   {
 202     Dim = dimensions
 203   };
 204   typedef Engine < Dim, T, EngineTag > Engine_t;
 205   typedef typename Engine_t::Domain_t Domain_t;
 206   typedef GuardLayers < Dim > GuardLayers_t;
 207 template < class Layout2 > FieldEngine (const Centering < Dim > &centering, const Layout2 & layout, const Mesh & mesh, int materials = 1):num_materials_m (materials), centering_m (centering),
 208     stride_m (centering.size ()), physicalCellDomain_m (layout.domain ()),
 209     guards_m (layout.externalGuards ()), mesh_m (mesh)
 210   {
 211   }
 212   unsigned int num_materials_m;
 213   Centering < Dim > centering_m;
 214   int stride_m;
 215   Domain_t physicalCellDomain_m;
 216   GuardLayers_t guards_m;
 217   Mesh mesh_m;
 218 };
 219
 220 template < class Subject > class SubFieldView;
 221 template < class Mesh, class T,
 222   class EngineTag > class SubFieldView < Field < Mesh, T, EngineTag > >
 223 {
 224 public:typedef Field < Mesh, T, EngineTag > Type_t;
 225 };
 226
 227 template < int Dim, class Mesh, class Domain > struct NewMeshTag
 228 {
 229   typedef Mesh Type_t;
 230 };
 231 template < class Mesh, class T, class EngineTag,
 232   class Domain > struct View1Implementation <Field < Mesh, T, EngineTag >,
 233   Domain, false >
 234 {
 235   typedef Field < Mesh, T, EngineTag > Subject_t;
 236   typedef typename Subject_t::Engine_t Engine_t;
 237   typedef typename NewEngine < Engine_t, Domain >::Type_t NewEngine_t;
 238   typedef typename NewEngine_t::Element_t NewT_t;
 239   typedef typename NewEngine_t::Tag_t NewEngineTag_t;
 240   typedef typename NewMeshTag < NewEngine_t::dimensions, Mesh,
 241     Domain >::Type_t NewMeshTag_t;
 242   typedef Field < NewMeshTag_t, NewT_t, NewEngineTag_t > Type_t;
 243 };
 244 template < class Mesh, class T, class EngineTag,
 245   class Sub1 > struct View1 <Field < Mesh, T, EngineTag >, Sub1 >
 246 {
 247   typedef Field < Mesh, T, EngineTag > Subject_t;
 248   typedef typename Subject_t::Domain_t Domain_t;
 249   typedef TemporaryNewDomain1 < Domain_t, Sub1 > NewDomain_t;
 250   typedef typename NewDomain_t::SliceType_t SDomain_t;
 251   enum
 252   {
 253     sv = DomainTraits < SDomain_t >::singleValued
 254   };
 255   typedef View1Implementation < Subject_t, SDomain_t, sv > Dispatch_t;
 256   typedef typename Dispatch_t::Type_t Type_t;
 257 };
 258 template < class Mesh, class T = double, class EngineTag = Brick > class Field {
 259 public:typedef Mesh MeshTag_t;
 260   typedef Mesh Mesh_t;
 261   typedef Field < Mesh, T, EngineTag > This_t;
 262   typedef FieldEngine < Mesh, T, EngineTag > FieldEngine_t;
 263   enum
 264   {
 265     dimensions = FieldEngine_t::dimensions
 266   };
 267   typedef Engine < dimensions, T, EngineTag > Engine_t;
 268   typedef typename Engine_t::Domain_t Domain_t;
 269   typedef Centering < dimensions > Centering_t;
 270   template < class Layout2 > Field (const Centering_t & centering,
 271                                     const Layout2 & layout,
 272                                     const Mesh_t &
 273                                     mesh):fieldEngine_m (centering, layout,
 274                                                          mesh)
 275   {
 276   }
 277   inline typename SubFieldView < This_t >::Type_t center (int c) const
 278   {
 279   }
 280   inline typename View1 < This_t, Domain_t >::Type_t all () const
 281   {
 282   }
 283   template < class T1 > const This_t & operator= (const T1 & rhs) const
 284   {
 285   }
 286 private:  FieldEngine_t fieldEngine_m;
 287 };
 288
 289 struct UniformRectilinearTag
 290 {
 291 };
 292 struct CartesianTag
 293 {
 294 };
 295 template < class MeshTraits > struct CartesianURM;
 296 template < class MeshTraits > class UniformRectilinearMeshData;
 297 template < class MeshTraits > class UniformRectilinearMesh;
 298 template < int Dim, typename T = double, class MeshTag =
 299   UniformRectilinearTag, class CoordinateSystemTag = CartesianTag, int CDim =
 300   Dim > struct MeshTraits;
 301 template < int Dim, typename T, class MeshTag, class CoordinateSystemTag,
 302   int CDim > struct MeshTraitsBase
 303 {
 304   typedef MeshTraits < Dim, T, MeshTag, CoordinateSystemTag,
 305     CDim > MeshTraits_t;
 306   enum
 307   {
 308     dimensions = Dim
 309   };
 310   typedef Vector < CDim, T > PointType_t;
 311 };
 312 template < int Dim, typename T, int CDim > struct MeshTraits <Dim, T,
 313   UniformRectilinearTag, CartesianTag, CDim >:public MeshTraitsBase < Dim, T,
 314   UniformRectilinearTag, CartesianTag, CDim >
 315 {
 316   typedef typename MeshTraitsBase < Dim, T, UniformRectilinearTag,
 317     CartesianTag, CDim >::MeshTraits_t MeshTraits_t;
 318   typedef CartesianURM < MeshTraits_t > CoordinateSystem_t;
 319   typedef UniformRectilinearMeshData < MeshTraits_t > MeshData_t;
 320   typedef UniformRectilinearMesh < MeshTraits_t > Mesh_t;
 321   typedef Vector < CDim, T > SpacingsType_t;
 322 };
 323 template < int Dim > class NoMeshData:public RefCounted
 324 {
 325 public:NoMeshData ()
 326   {
 327   }
 328   template < class Layout >
 329     explicit NoMeshData (const Layout &
 330                          layout):physicalVertexDomain_m (layout.
 331                                                          innerDomain ()),
 332     physicalCellDomain_m (shrinkRight (physicalVertexDomain_m, 1)),
 333     totalVertexDomain_m (layout.domain ()),
 334     totalCellDomain_m (shrinkRight (totalVertexDomain_m, 1))
 335   {
 336   }
 337 private:Interval < Dim > physicalVertexDomain_m, physicalCellDomain_m;
 338   Interval < Dim > totalVertexDomain_m, totalCellDomain_m;
 339 };
 340
 341 template < class MeshTraits > class UniformRectilinearMeshData:public NoMeshData <
 342   MeshTraits::
 343   dimensions >
 344 {
 345 public:typedef typename
 346     MeshTraits::MeshData_t
 347     MeshData_t;
 348   typedef typename
 349     MeshTraits::PointType_t
 350     PointType_t;
 351   typedef typename
 352     MeshTraits::SpacingsType_t
 353     SpacingsType_t;
 354   enum
 355   {
 356     dimensions = MeshTraits::dimensions
 357   };
 358   template < class Layout > UniformRectilinearMeshData (const Layout & layout,
 359                                                         const PointType_t &
 360                                                         origin,
 361                                                         const SpacingsType_t &
 362                                                         spacings):
 363     NoMeshData <
 364   dimensions > (layout),
 365   origin_m (origin),
 366   spacings_m (spacings)
 367   {
 368   }
 369 private:PointType_t origin_m;
 370   SpacingsType_t
 371     spacings_m;
 372 };
 373
 374 template < class MeshTraits > class UniformRectilinearMesh:public MeshTraits::
 375   CoordinateSystem_t
 376 {
 377 public:typedef MeshTraits
 378     MeshTraits_t;
 379   typedef typename
 380     MeshTraits::MeshData_t
 381     MeshData_t;
 382   typedef typename
 383     MeshTraits::PointType_t
 384     PointType_t;
 385   typedef typename
 386     MeshTraits::SpacingsType_t
 387     SpacingsType_t;
 388   enum
 389   {
 390     dimensions = MeshTraits::dimensions
 391   };
 392   template < class Layout >
 393     inline UniformRectilinearMesh (const Layout & layout,
 394                                    const PointType_t & origin,
 395                                    const SpacingsType_t & spacings):
 396   data_m (new MeshData_t (layout, origin, spacings))
 397   {
 398   }
 399 private:RefCountedPtr < MeshData_t > data_m;
 400 };
 401
 402 template < class MeshTraits > struct GenericURM
 403 {
 404 };
 405 template < class MeshTraits > struct CartesianURM:
 406   public
 407   GenericURM <
 408   MeshTraits >
 409 {
 410 };
 411 template < int
 412   dim,
 413   class
 414   MeshTag = UniformRectilinearTag, class CoordinateSystemTag = CartesianTag > struct ParallelTraits {
 415   enum
 416   {
 417     Dim = dim
 418   };
 419   typedef
 420     GridLayout <
 421     dim >
 422     Layout_t;
 423   typedef
 424     MeshTraits <
 425     dim, double,
 426     MeshTag,
 427     CoordinateSystemTag >
 428     MeshTraits_t;
 429   typedef typename
 430     MeshTraits_t::Mesh_t
 431     Mesh_t;
 432   typedef
 433     MultiPatch <
 434     GridTag,
 435     Remote <
 436   Brick > >
 437     Engine_t;
 438 };
 439 template < class ComputeTraits > struct RhalkTraits:
 440   public
 441   ComputeTraits
 442 {
 443   typedef typename
 444     ComputeTraits::Mesh_t
 445     Mesh_t;
 446   typedef typename
 447     ComputeTraits::Engine_t
 448     Engine_t;
 449   enum
 450   {
 451     Dim = ComputeTraits::Dim
 452   };
 453   typedef
 454     Centering <
 455     Dim >
 456     Centering_t;
 457   typedef typename
 458     Mesh_t::SpacingsType_t
 459     Spacings_t;
 460   typedef
 461     Field <
 462     Mesh_t, double,
 463     Engine_t >
 464     Scalar_t;
 465 };
 466 enum
 467 {
 468   Dim = 3
 469 };
 470 typedef
 471   RhalkTraits <
 472   ParallelTraits <
 473   Dim,
 474   UniformRectilinearTag,
 475 CartesianTag > >
 476   Traits_t;
 477 Vector < Dim > origin;
 478 Traits_t::Spacings_t spacings;
 479 int
 480 main (int argc, char **argv)
 481 {
 482   Traits_t::Layout_t layout;
 483   Traits_t::Mesh_t mesh (layout, origin, spacings);
 484   Traits_t::Centering_t face =
 485     canonicalCentering < Traits_t::Dim > (FaceType, Continuous);
 486   Traits_t::Scalar_t v (face, layout, mesh);
 487   for (int i = 0; i < Dim; ++i)
 488     v.center (i).all () = std::numeric_limits < double >::signaling_NaN ();
 489 }