kdbg/testprogs/testfile.cpp

   1 #include <iostream>
   2 #include <qstring.h>
   3 #include <qfile.h>
   4 #include <qfileinfo.h>
   5 #include <qdir.h>
   6 #include <math.h>
   7
   8 enum E { red, green, blue, yellow };
   9 struct S { int x, y; S* s; };
  10
  11 struct emptyBase { };
  12 struct emptyDerived : S { };
  13 struct emptyNested : emptyBase { };
  14 struct emptyVBase { virtual ~emptyVBase(){} };
  15 struct emptyVDerived : S { virtual ~emptyVDerived(){} };
  16 struct emptyVNested : emptyVBase { };
  17
  18 int globalvar = 1234;
  19
  20 class Cl
  21 {
  22         int k;
  23         double l;
  24 public:
  25         Cl(int r);
  26         virtual ~Cl();
  27         virtual int f(int x);
  28 };
  29
  30 typedef void (*PtrFunc)(E*, char);
  31
  32 class Dl : public Cl
  33 {
  34 public:
  35         Dl(int r);
  36         virtual int f(int x);
  37         int operator()(const QString& x, int& y) const;
  38         operator const char*() { return 0; }
  39         operator PtrFunc*();
  40 };
  41
  42 namespace A {
  43 namespace {
  44 namespace B {
  45 namespace {
  46 namespace {
  47 void g()
  48 {
  49         S s1, s2;
  50         s1.x = 85;
  51         s2.y = 17;
  52         s1.s = &s2;
  53         s2.s = &s1;
  54 }
  55 } // namespace
  56 void Banong() { g(); }
  57 } // namespace
  58 void g() { Banong(); }
  59 } // namespace B
  60 void Aanong() { B::g(); }
  61 } // namespace
  62 void g() { Aanong(); }
  63 } // namespace A
  64
  65 void f(E e[3], char c)
  66 {
  67         E x = e[2];
  68         S y[2];
  69         E* pe = e;
  70         E* pea[3] = { pe, };
  71         {
  72                 int x = 17;
  73                 x;
  74         }
  75         A::g();
  76         char buffer[300];
  77         memset(buffer, 1, 300);
  78         for (int i = 0; i < sizeof(buffer); i +=15) buffer[i] = '\02';
  79         QDir dir;
  80         QFile file;
  81         QFileInfo fi;
  82         x = red;
  83         emptyBase eb;
  84         emptyDerived ed;
  85         emptyNested en;
  86         int ea[3];
  87         emptyVBase evb;
  88         emptyVDerived evd;
  89         emptyVNested evn;
  90 }
  91
  92 void strtest(const char* t)
  93 {
  94     const char* s = t;
  95     const char*& s2 = s;
  96     if (t == 0)
  97         strtest(s2);
  98     std::cout << s2 << std::endl;
  99 }
 100
 101 template<typename F>
 102 void templated_strtest(F f, const char* t)
 103 {
 104         f(t);
 105 }
 106
 107 void segFault()
 108 {
 109         *(char*)0 = 's';
 110 }
 111
 112 int main(int argc, char* argv[])
 113 {
 114         if (argc > 1) {
 115                 if (*argv[1] == 's') {
 116                         segFault();
 117                 } else if (*argv[1] == 'a') {
 118                         // let debugger attach
 119                         int junk;
 120                         std::cin >> junk;
 121                 }
 122         }
 123
 124         char a[6] = { 'a', 'B', '\'', '\"' };
 125         char a1[1] = { '1' };
 126         E e[3] = { red, green, blue };
 127         E e1[1] = { yellow };
 128
 129         a[0] = '5';
 130         void (*pf[2])(E*, char) = {f};
 131         {
 132                 double d[1] = { -1.234e123 };
 133                 int i = 10;
 134                 sin(i);
 135         }
 136         (*pf[0])(e, '\n');
 137
 138         QString s;
 139
 140         s = "Hi, there!\r\n\t\"\'\\";
 141
 142         const QString& strref = s;
 143
 144         templated_strtest(strtest, s);
 145         s = "asbcxxxxxxxxxxxxxxxxxxxxxxxxxxx";
 146         strtest(s);
 147         s += "iiiiiiiiiiiiiiiiiiiiiiiiiiiiiii";
 148         strtest(s);
 149         s += "rst";
 150         strtest(s);
 151         s = "xxxxxxxxxxxxxxxxxxxxxxxxxxx";
 152         strtest(s);
 153         s += "rst";
 154         strtest(s);
 155         s = "";
 156
 157         Cl c1(13);
 158         Dl d1(3214);
 159         d1.f(17);
 160         int n = 83;
 161         d1(strref, n);
 162         PtrFunc* ppf = d1;
 163 }
 164
 165 Cl::Cl(int r) :
 166         k(r),
 167         l(sin(r))
 168 {
 169     std::cout << l << std::endl;
 170 }
 171
 172 Cl::~Cl()
 173 {
 174 }
 175
 176 int Cl::f(int x)
 177 {
 178         int y = 2*x;
 179         return y;
 180 }
 181
 182 Dl::Dl(int r) :
 183         Cl(r)
 184 {
 185 }
 186
 187 int Dl::f(int x)
 188 {
 189         int y = Cl::f(x);
 190         return y+3;
 191 }
 192
 193 int Dl::operator()(const QString& x, int& y) const
 194 {
 195         std::cerr << "ha! I know!" << std::endl;
 196         return 1;
 197 }
 198
 199 Dl::operator PtrFunc*()
 200 {
 201     return 0;
 202 }