← Back to branch summary

~ubuntu-branches/ubuntu/vivid/dpkg/vivid

« back to all changes in this revision

Viewing changes to scripts/t/Dpkg_Shlibs/patterns.cpp

  • Committer: Package Import Robot
  • Author(s): Adam Conrad
  • Date: 2014-04-21 18:14:10 UTC
  • mfrom: (1.6.8 sid)
  • Revision ID: package-import@ubuntu.com-20140421181410-94kvb2zodjd2og32
Tags: 1.17.7ubuntu1
* Merge from Debian unstable.  Remaining changes:
  - Allow -fstack-protector on arm64 now that GCC and glibc support it.
  - Change native source version/format mismatch errors into warnings
    until the dust settles on Debian bug 737634 about override options.
  - Add DPKG_UNTRANSLATED_MESSAGES environment check so that higher-level
    tools can get untranslated dpkg terminal log messages while at the
    same time having translated debconf prompts.
  - Special-case arm{el,hf} ELF objects in Shlibs/Objdump.pm for multilib.
  - Map unqualified package names of multiarch-same packages to the native
    arch instead of throwing an error, so that we don't break on upgrade
    when there are unqualified names stored in the dpkg trigger database.
  - Add logic to the postinst to `dpkg --add-architecture i386' on new
    installs on amd64, mimicking our previous behaviour with the conffile.
  - Apply a workaround from mvo to consider RC packages as multiarch,
    during the dpkg consistency checks. (see LP: 1015567 and 1057367).
* Drop obsolete migration code and guards from pre-trusty dpkg versions.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scripts/t/Dpkg_Shlibs/patterns.cpp
 
1
#define EXPORT(x) x {}
 
2
 
 
3
namespace NSA
 
4
{
 
5
    class ClassA
 
6
    {
 
7
        private:
 
8
            class Private
 
9
            {
 
10
                public:
 
11
                    Private();
 
12
                    virtual ~Private();
 
13
                    void privmethod1(int);
 
14
                    void privmethod2(int);
 
15
            };
 
16
            Private *p;
 
17
            class Internal
 
18
            {
 
19
                public:
 
20
                    Internal();
 
21
                    virtual ~Internal();
 
22
                    void internal_method1(char);
 
23
                    void internal_method2(char);
 
24
            };
 
25
            Internal *i;
 
26
        public:
 
27
            ClassA();
 
28
            virtual ~ClassA();
 
29
            virtual void generate_vt(const char *) const;
 
30
    };
 
31
 
 
32
    EXPORT(ClassA::Private::Private());
 
33
    EXPORT(ClassA::Private::~Private());
 
34
    EXPORT(void ClassA::Private::privmethod1(int));
 
35
    EXPORT(void ClassA::Private::privmethod2(int));
 
36
 
 
37
    EXPORT(ClassA::Internal::Internal());
 
38
    EXPORT(ClassA::Internal::~Internal());
 
39
    EXPORT(void ClassA::Internal::internal_method1(char));
 
40
    EXPORT(void ClassA::Internal::internal_method2(char));
 
41
 
 
42
    EXPORT(ClassA::ClassA());
 
43
    EXPORT(ClassA::~ClassA());
 
44
    EXPORT(void ClassA::generate_vt(const char *) const);
 
45
};
 
46
 
 
47
class ClassB
 
48
{
 
49
    public:
 
50
        ClassB();
 
51
        virtual ~ClassB();
 
52
        virtual void generate_vt(const char *) const;
 
53
};
 
54
 
 
55
EXPORT(ClassB::ClassB());
 
56
EXPORT(ClassB::~ClassB());
 
57
EXPORT(void ClassB::generate_vt(const char *) const);
 
58
 
 
59
class ClassC
 
60
{
 
61
    public:
 
62
        ClassC();
 
63
        virtual ~ClassC();
 
64
        virtual void generate_vt(const char *) const;
 
65
};
 
66
 
 
67
EXPORT(ClassC::ClassC());
 
68
EXPORT(ClassC::~ClassC());
 
69
EXPORT(void ClassC::generate_vt(const char *) const);
 
70
 
 
71
namespace NSB
 
72
{
 
73
    class ClassD : public NSA::ClassA, public ClassB, public ClassC
 
74
    {
 
75
        public:
 
76
            ClassD();
 
77
            virtual ~ClassD();
 
78
            virtual void generate_vt(const char *) const;
 
79
    };
 
80
 
 
81
    EXPORT(ClassD::ClassD());
 
82
    EXPORT(ClassD::~ClassD());
 
83
    EXPORT(void ClassD::generate_vt(const char *) const);
 
84
 
 
85
    class Symver {
 
86
        public:
 
87
            Symver();
 
88
            ~Symver();
 
89
 
 
90
            void symver_method1();
 
91
            void symver_method2();
 
92
    };
 
93
 
 
94
    EXPORT(Symver::Symver());
 
95
    EXPORT(Symver::~Symver());
 
96
    EXPORT(void Symver::symver_method1());
 
97
    EXPORT(void Symver::symver_method2());
 
98
 
 
99
    class SymverOptional {
 
100
        public:
 
101
            SymverOptional();
 
102
            ~SymverOptional();
 
103
    };
 
104
 
 
105
    EXPORT(SymverOptional::SymverOptional());
 
106
    EXPORT(SymverOptional::~SymverOptional());
 
107
};