gcc/testsuite/gdc.test/compilable/dtoh_enum_cpp98.d

   1 /+
   2 REQUIRED_ARGS: -extern-std=c++98 -HC -c -o-
   3 PERMUTE_ARGS:
   4 TEST_OUTPUT:
   5 ---
   6 // Automatically generated by Digital Mars D Compiler
   7
   8 #pragma once
   9
  10 #include <assert.h>
  11 #include <math.h>
  12 #include <stddef.h>
  13 #include <stdint.h>
  14
  15 #ifdef CUSTOM_D_ARRAY_TYPE
  16 #define _d_dynamicArray CUSTOM_D_ARRAY_TYPE
  17 #else
  18 /// Represents a D [] array
  19 template<typename T>
  20 struct _d_dynamicArray final
  21 {
  22     size_t length;
  23     T *ptr;
  24
  25     _d_dynamicArray() : length(0), ptr(NULL) { }
  26
  27     _d_dynamicArray(size_t length_in, T *ptr_in)
  28         : length(length_in), ptr(ptr_in) { }
  29
  30     T& operator[](const size_t idx) {
  31         assert(idx < length);
  32         return ptr[idx];
  33     }
  34
  35     const T& operator[](const size_t idx) const {
  36         assert(idx < length);
  37         return ptr[idx];
  38     }
  39 };
  40 #endif
  41
  42 static int32_t const Anon = 10;
  43
  44 static bool const Anon2 = true;
  45
  46 static const char* const Anon3 = "wow";
  47
  48 enum Enum
  49 {
  50     Enum_One = 0,
  51     Enum_Two = 1,
  52 };
  53
  54 enum EnumDefaultType
  55 {
  56     EnumDefaultType_One = 1,
  57     EnumDefaultType_Two = 2,
  58 };
  59
  60 enum EnumWithType
  61 {
  62     EnumWithType_One = 1,
  63     EnumWithType_Two = 2,
  64 };
  65
  66 enum
  67 {
  68     AnonOne = 1,
  69     AnonTwo = 2,
  70 };
  71
  72 enum
  73 {
  74     AnonWithTypeOne = 1LL,
  75     AnonWithTypeTwo = 2LL,
  76 };
  77
  78 namespace EnumWithStringType
  79 {
  80     static const char* const One = "1";
  81     static const char* const Two = "2";
  82 };
  83
  84 namespace EnumWithImplicitType
  85 {
  86     static const char* const One = "1";
  87     static const char* const Two = "2";
  88 };
  89
  90 namespace
  91 {
  92     static const char* const AnonWithStringOne = "1";
  93     static const char* const AnonWithStringTwo = "2";
  94 };
  95
  96 static int32_t const AnonMixedOne = 1;
  97 static int64_t const AnonMixedTwo = 2LL;
  98 static const char* const AnonMixedA = "a";
  99
 100
 101 enum STC
 102 {
 103     STC_a = 1,
 104     STC_b = 2,
 105 };
 106
 107 static STC const STC_D = (STC)3;
 108
 109 struct Foo final
 110 {
 111     int32_t i;
 112     Foo() :
 113         i()
 114     {
 115     }
 116     Foo(int32_t i) :
 117         i(i)
 118         {}
 119 };
 120
 121 namespace MyEnum
 122 {
 123     static Foo const A = Foo(42);
 124     static Foo const B = Foo(84);
 125 };
 126
 127 static /* MyEnum */ Foo const test = Foo(42);
 128
 129 struct FooCpp final
 130 {
 131     int32_t i;
 132     FooCpp() :
 133         i()
 134     {
 135     }
 136     FooCpp(int32_t i) :
 137         i(i)
 138         {}
 139 };
 140
 141 namespace MyEnumCpp
 142 {
 143     static FooCpp const A = FooCpp(42);
 144     static FooCpp const B = FooCpp(84);
 145 };
 146
 147 static /* MyEnum */ Foo const testCpp = Foo(42);
 148
 149 extern const bool e_b;
 150 ---
 151 +/
 152
 153 extern(C++):
 154 enum Anon = 10;
 155 extern(C++) enum Anon2 = true;
 156 extern(C++) enum Anon3 = "wow";
 157
 158 enum Enum
 159 {
 160     One,
 161     Two
 162 }
 163
 164 enum EnumDefaultType : int
 165 {
 166     One = 1,
 167     Two = 2
 168 }
 169
 170 enum EnumWithType : byte
 171 {
 172     One = 1,
 173     Two = 2
 174 }
 175
 176 enum
 177 {
 178     AnonOne = 1,
 179     AnonTwo = 2
 180 }
 181
 182 enum : long
 183 {
 184     AnonWithTypeOne = 1,
 185     AnonWithTypeTwo = 2
 186 }
 187
 188 enum EnumWithStringType : string
 189 {
 190     One = "1",
 191     Two = "2"
 192 }
 193
 194 enum EnumWithImplicitType
 195 {
 196     One = "1",
 197     Two = "2"
 198 }
 199
 200 enum : string
 201 {
 202     AnonWithStringOne = "1",
 203     AnonWithStringTwo = "2"
 204 }
 205
 206 enum
 207 {
 208     AnonMixedOne = 1,
 209     long AnonMixedTwo = 2,
 210     string AnonMixedA = "a"
 211 }
 212
 213 enum STC
 214 {
 215     a = 1,
 216     b = 2,
 217 }
 218
 219 extern(C++) enum STC_D = STC.a | STC.b;
 220
 221 struct Foo { int i; }
 222 enum MyEnum { A = Foo(42), B = Foo(84) }
 223 extern(C++) enum test = MyEnum.A;
 224
 225 extern(C++) struct FooCpp { int i; }
 226 enum MyEnumCpp { A = FooCpp(42), B = FooCpp(84) }
 227 extern(C++) enum testCpp = MyEnum.A;
 228
 229 // currently unsupported enums
 230 extern(C++) enum b = [1, 2, 3];
 231 extern(C++) enum c = [2: 3];
 232
 233 extern(C) void foo();
 234 extern(C++) enum d = &foo;
 235
 236 __gshared immutable bool e_b;
 237 extern(C++) enum e = &e_b;
 238
 239 // Opaque enums require C++ 11
 240 enum opaque;
 241 enum typedOpaque : long;
 242 enum arrayOpaque : int[4];
 243
 244 extern(D) enum hidden_d = 42; // Linkage prevents being exported to C++