File: fragile.h

package info (click to toggle)
pypy3 7.0.0%2Bdfsg-3
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 111,848 kB
  • sloc: python: 1,291,746; ansic: 74,281; asm: 5,187; cpp: 3,017; sh: 2,533; makefile: 544; xml: 243; lisp: 45; csh: 21; awk: 4
file content (124 lines) | stat: -rw-r--r-- 1,997 bytes parent folder | download | duplicates (7)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
namespace fragile {

class no_such_class;

class A {
public:
    virtual int check() { return (int)'A'; }
    virtual A* gime_null() { return (A*)0; }
};

class B {
public:
    virtual int check() { return (int)'B'; }
    no_such_class* gime_no_such() { return 0; }
};

class C {
public:
    virtual int check() { return (int)'C'; }
    void use_no_such(no_such_class*) {}
};

class D {
public:
    virtual int check() { return (int)'D'; }
    virtual int check(int, int) { return (int)'D'; }
    void overload() {}
    void overload(no_such_class*) {}
    void overload(char, int i = 0) {}  // Reflex requires a named arg
    void overload(int, no_such_class* p = 0) {}
};


static const int dummy_location = 0xdead;

class E {
public:
    E() : m_pp_no_such((no_such_class**)&dummy_location), m_pp_a(0) {}

    virtual int check() { return (int)'E'; }
    void overload(no_such_class**) {}

    no_such_class** m_pp_no_such;
    A** m_pp_a;
};

class F {
public:
    F() : m_int(0) {}
    virtual int check() { return (int)'F'; }
    int m_int;
};

class G {
public:
    enum { unnamed1=24, unnamed2=96 };

    class GG {};
};

class H {
public:
    class HH {
    public:
       HH* copy();
    };
    HH* m_h;
};

class I {
public:
    operator bool() { return 0; }
};

extern I gI;

class J {
public:
    int method1(int, double) { return 0; }
};

void fglobal(int, double, char);

namespace nested1 {
    class A {};
    namespace nested2 {
        class A {};
        namespace nested3 {
            class A {};
        } // namespace nested3
    } // namespace nested2
} // namespace nested1

class K {
public:
    virtual ~K();
    K* GimeK(bool derived);
    K* GimeL();
};

class L : public K {
public:
    virtual ~L();
    no_such_class* m_no_such;
};

class M {
public:
    virtual ~M() {}
    enum E1 { kOnce=42 };
    enum E2 { kTwice=12 };
};

class N : public M {
public:
    enum E2 { kTwice=12 };
};

class O {
public:
   virtual int abstract() = 0;
};

} // namespace fragile