home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1999 mARCH / PCWK3A99.iso / Linux / DDD331 / DDD-3_1_.000 / DDD-3_1_ / ddd-3.1.1 / ddd / cxxtest.C < prev    next >
C/C++ Source or Header  |  1998-10-27  |  11KB  |  503 lines
  1. // $Id: cxxtest.C,v 1.37 1998/10/27 10:00:50 zeller Exp $ 
  2. // Test program
  3.  
  4. // Copyright (C) 1995 Technische Universitaet Braunschweig, Germany.
  5. // Written by Dorothea Luetkehaus <luetke@ips.cs.tu-bs.de>.
  6. // 
  7. // This file is part of DDD.
  8. // 
  9. // DDD is free software; you can redistribute it and/or
  10. // modify it under the terms of the GNU General Public
  11. // License as published by the Free Software Foundation; either
  12. // version 2 of the License, or (at your option) any later version.
  13. // 
  14. // DDD is distributed in the hope that it will be useful,
  15. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  16. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17. // See the GNU General Public License for more details.
  18. // 
  19. // You should have received a copy of the GNU General Public
  20. // License along with DDD -- see the file COPYING.
  21. // If not, write to the Free Software Foundation, Inc.,
  22. // 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  23. // 
  24. // DDD is the data display debugger.
  25. // For details, see the DDD World-Wide-Web page, 
  26. // `http://www.cs.tu-bs.de/softech/ddd/',
  27. // or send a mail to the DDD developers <ddd@ips.cs.tu-bs.de>.
  28.  
  29. //--------------------------------------------------------------------------
  30. // This program defines some data structures and values that may be
  31. // examined using DDD.
  32. //--------------------------------------------------------------------------
  33.  
  34. char cxxtest_rcsid[] =
  35.     "$Id: cxxtest.C,v 1.37 1998/10/27 10:00:50 zeller Exp $";
  36.  
  37. #include "config.h"
  38. #include "bool.h"
  39.  
  40. #include <iostream.h>
  41. #include <stdlib.h>
  42. #include <time.h>
  43. #include <math.h>
  44.  
  45. //--------------------------------------------------------------------------
  46. extern "C" {
  47. #if HAVE_RANDOM && !HAVE_RANDOM_DECL && !defined(random)
  48. long int random();
  49. #endif
  50. #if HAVE_SRANDOM && !HAVE_SRANDOM_DECL && !defined(srandom)
  51. void srandom(unsigned int seed);
  52. #endif
  53. #if HAVE_RAND && !HAVE_RAND_DECL && !defined(rand)
  54. int rand();
  55. #endif
  56. #if HAVE_SRAND && !HAVE_SRAND_DECL && !defined(srand)
  57. void srand(unsigned int seed);
  58. #endif
  59. };
  60.  
  61. static void init_random_seed()
  62. {
  63.     static bool seed_initialized = false;
  64.     if (seed_initialized)
  65.     return;
  66.  
  67.     time_t tm;
  68.     time(&tm);
  69.  
  70. #if HAVE_SRAND
  71.     srand((int)tm);
  72. #elif HAVE_SRANDOM
  73.     srandom((int)tm);
  74. #endif
  75.  
  76.     seed_initialized = true;
  77. }
  78.  
  79. static int rnd(int x)
  80. { 
  81.     init_random_seed();
  82.  
  83. #if HAVE_RAND
  84.     return rand() % x;
  85. #else /* HAVE_RANDOM */
  86.     return random() % x;
  87. #endif
  88. }
  89.  
  90. enum DayOfWeek {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
  91.  
  92. static int a_global = 42;    // Place watchpoints on this one
  93.  
  94. //--------------------------------------------------------------------------
  95. class Date {
  96.     DayOfWeek day_of_week;
  97.     int day;
  98.     int month;
  99.     int year;
  100. public:
  101.     Date() 
  102.     : day_of_week(Thu), day(1), month(1), year(1970)
  103.     {}
  104.     Date(DayOfWeek w, int d, int m, int y)
  105.     : day_of_week(w), day(d), month(m), year(y)
  106.     {}
  107.     virtual ~Date()
  108.     {}
  109.     void set(DayOfWeek w, int d, int m, int y)
  110.     {
  111.     day_of_week = w;
  112.     day         = d;
  113.     month       = m;
  114.     year        = y;
  115.     }
  116.  
  117.     virtual void print()    {}
  118.     virtual void print(int) {}
  119. };
  120.  
  121. //--------------------------------------------------------------------------
  122. class Holiday : public Date {
  123.     const char *name;
  124.  
  125. public:
  126.     Holiday(DayOfWeek w, int d, int m, int y, const char *n) :
  127.     Date (w, d, m, y), name(n)
  128.     {
  129.     a_global = 1;
  130.     }
  131.     virtual ~Holiday()
  132.     {}
  133.  
  134.     virtual void print()    {}
  135.     virtual void print(int) {}
  136. };
  137.  
  138. //--------------------------------------------------------------------------
  139. class Tree {
  140.     int   value;
  141.     const char *_name;
  142.  
  143.     Tree *_left;
  144.     Tree *_right;
  145.     bool left_thread;
  146.     bool right_thread;
  147.  
  148. protected:
  149.     void add_left_threads(Tree *);
  150.     void add_right_threads(Tree *);
  151.  
  152. public:
  153.     Date date;
  154.  
  155.     static int shared;
  156.  
  157.     Tree(int v, const char *n):
  158.     value(v), _name(n), _left(0), _right(0), 
  159.     left_thread(false), right_thread(false)
  160.     {}
  161.  
  162.     Tree *left()  { return left_thread  ? 0 : _left; }
  163.     Tree *right() { return right_thread ? 0 : _right; }
  164.  
  165.     const char *name() { return _name; }
  166.  
  167.     void set_left(Tree *t)  { _left = t; }
  168.     void set_right(Tree *t) { _right = t; }
  169.  
  170.     // In-order traversal
  171.     Tree *first();
  172.     Tree *next();
  173.     Tree *last();
  174.     Tree *prev();
  175.  
  176.     ~Tree()
  177.     {
  178.     delete left();
  179.      delete right();
  180.     }
  181.  
  182.     void add_threads();
  183. };
  184.  
  185. int Tree::shared = 4711;
  186.  
  187. void Tree::add_threads()
  188. {
  189.     add_left_threads(0);
  190.     add_right_threads(0);
  191. }
  192.  
  193. void Tree::add_right_threads(Tree *parent)
  194. {
  195.     if (_right == 0)
  196.     {
  197.     _right = parent;
  198.     right_thread = (_right != 0);
  199.     }
  200.     else
  201.     {
  202.     _right->add_right_threads(parent);
  203.     }
  204.  
  205.     if (_left != 0 && !left_thread)
  206.     _left->add_right_threads(this);
  207. }
  208.  
  209. void Tree::add_left_threads(Tree *parent)
  210. {
  211.     if (_left == 0)
  212.     {
  213.     _left = parent;
  214.     left_thread = (_left != 0);
  215.     }
  216.     else
  217.     {
  218.     _left->add_left_threads(parent);
  219.     }
  220.  
  221.     if (_right != 0 && !right_thread)
  222.     _right->add_left_threads(this);
  223. }
  224.  
  225. Tree *Tree::next()
  226. {
  227.     if (right_thread)
  228.     return _right;
  229.     if (_right != 0)
  230.     return _right->first();
  231.     return 0;
  232. }
  233.  
  234. Tree *Tree::prev()
  235. {
  236.     if (left_thread)
  237.     return _left;
  238.     if (_left != 0)
  239.     return _left->last();
  240.     return 0;
  241. }
  242.  
  243. Tree *Tree::first()
  244. {
  245.     Tree *t = this;
  246.     while (t->_left != 0 && !t->left_thread)
  247.     t = t->_left;
  248.  
  249.     return t;
  250. }
  251.  
  252. Tree *Tree::last()
  253. {
  254.     Tree *t = this;
  255.     while (t->_right != 0 && !t->right_thread)
  256.     t = t->_right;
  257.  
  258.     return t;
  259. }
  260.  
  261. //--------------------------------------------------------------------------
  262. class List {
  263.     int value;
  264. public:
  265.     List *self;
  266.     List *next;
  267.  
  268.     List(int v):
  269.     value(v), self(this), next(this)
  270.     {}
  271. };
  272. //--------------------------------------------------------------------------
  273. // Simple threaded tree
  274.  
  275. void tree_test()
  276. {
  277.     Tree *tree = 0;
  278.  
  279.     tree = new Tree(7, "Ada");                        // Byron Lovelace
  280.     tree->set_left(new Tree(1, "Grace"));             // Murray Hopper
  281.     tree->left()->set_left(new Tree(5, "Judy"));      // Clapp
  282.     tree->left()->set_right(new Tree(6, "Kathleen")); // McNulty
  283.     tree->set_right(new Tree(1, "Mildred"));          // Koss
  284.  
  285.     tree->add_threads();
  286.  
  287.     for (Tree *t = tree->first(); t != 0; t = t->next())
  288.     cout << t->name() << " ";
  289.     cout << "\n";
  290.  
  291.     (void) tree;        // Display this
  292.  
  293.     tree->date.set(Tue, 29, 11, 1994);
  294.     tree->date.set(Wed, 30, 11, 1994);
  295.  
  296.     delete tree;
  297. }
  298.  
  299. //--------------------------------------------------------------------------
  300. // Simple circular list.  Examine `list' with alias detection enabled.
  301. void list_test(int start)
  302. {
  303.     List *list = 0;
  304.  
  305.     list                         = new List(a_global + start++);
  306.     list->next                   = new List(a_global + start++);
  307.     list->next->next             = new List(a_global + start++);
  308.     list->next->next->next       = list;
  309.  
  310.     (void) list;        // Display this
  311.  
  312.     delete list->next->next;
  313.     delete list->next;
  314.     delete list;
  315. }
  316.  
  317. // Test disambiguation
  318. void list_test(double d)
  319. {
  320.     list_test(int(d));
  321. }
  322.  
  323. //--------------------------------------------------------------------------
  324. void reference_test(Date& date, Date*& date_ptr)
  325. {
  326.     date = *date_ptr;
  327.     delete date_ptr;
  328.     date_ptr = 0;
  329. }
  330.  
  331. //--------------------------------------------------------------------------
  332. void array_test()
  333. {
  334.     // Play with rotate and show/hide buttons
  335.     DayOfWeek days_of_week[7] = {Sun, Mon, Tue, Wed, Thu, Fri, Sat};
  336.  
  337.     char *twodim [2][3] = {{ "Pioneering", "women", "in"},
  338.                { "computer", "science", "!"}};
  339.  
  340.     int array[12][12];
  341.  
  342.     (void) twodim;        // Display this
  343.     (void) days_of_week;    // Display this
  344.     (void) array;        // Display this
  345.  
  346.     // Initialize array
  347.     for (int i = 0; i < int(sizeof(array) / sizeof(array[0])); i++)
  348.     for (int j = 0; j < int(sizeof(array[0]) / sizeof(array[0][0])); j++)
  349.         array[i][j] = 0;
  350.  
  351.     // Dereference this
  352.     Date *date_ptrs[4];
  353.     date_ptrs[0] = new Date(Thu, 1, 9, 1994);
  354.     date_ptrs[1] = new Date(Tue, 10, 5, 1994);
  355.     date_ptrs[2] = new Date(Fri, 15, 7, 1994);
  356.     date_ptrs[3] = new Date(Sat, 24, 12, 1994);
  357.  
  358.     Date *date_ptr;
  359.     for (int k = 0; k < 4; k++)
  360.     {
  361.     // Dereference DATE_PTR to see it traverse the individual *DATE_PTRs
  362.     date_ptr = date_ptrs[k];
  363.     reference_test(*date_ptr, date_ptrs[k]);
  364.     a_global = k;
  365.     }
  366.  
  367.     // A `repeat' test.
  368.     static int *ar[100];
  369.     static int     ir[100];
  370.  
  371.     ar[1]  = &ir[1];    ir[1]  = 1;
  372.     ar[50] = &ir[50];    ir[50] = 50;
  373.     ar[51] = &ir[51];    ir[51] = 51;
  374.     ar[99] = &ir[99];    ir[99] = 99;
  375. }
  376.  
  377. //--------------------------------------------------------------------------
  378. #define numbers(x) (sizeof((x)) / sizeof((x)[0]))
  379.  
  380. void shell_sort(int a[], int size)
  381. {
  382.     int h = 1;
  383.     do {
  384.     h = h * 3 + 1;
  385.     } while (h <= size);
  386.     do {
  387.     h /= 3;
  388.     for (int i = h; i < size; i++)
  389.     {
  390.         int v = a[i];
  391.         int j;
  392.         for (j = i; j >= h && a[j - h] > v; j -= h)
  393.         a[j] = a[j - h];
  394.         if (i != j)
  395.         a[j] = v;
  396.     }
  397.     } while (h != 1);
  398. }
  399.  
  400. void plot_test()
  401. {
  402.     static int ir[100];
  403.  
  404.     for (int k = 0; k < numbers(ir); k++)
  405.     ir[k] = rnd(100);
  406.  
  407.     shell_sort(ir, numbers(ir));
  408.  
  409.     (void) ir;            // Plot this
  410.  
  411.     static double dr[10][100];
  412.     double pi = 3.14159265358979323846;
  413.  
  414.     for (int i = 0; i < numbers(dr); i++)
  415.     for (int j = 0; j < numbers(dr[0]); j++)
  416.         dr[i][j] = i * i * sin(j * 2 * pi / numbers(dr[0]) * 3);
  417.  
  418.     (void) dr;            // Plot this
  419. }
  420.  
  421. //--------------------------------------------------------------------------
  422. void type_test()
  423. {
  424.     Holiday new_years_eve(Sat, 31, 12, 1994, 
  425.               "May all acquaintance be forgot");
  426.  
  427.     Date *date = new Date(Sat, 24, 12, 1994);
  428.     void *voidptr = date;
  429.  
  430.     (void) voidptr;        // Use it
  431.  
  432.     struct Uni {
  433.     int ii;
  434.     unsigned bit1:1;
  435.     unsigned bit2:2;
  436.     union {
  437.         int j;
  438.         char c;
  439.     }u;
  440.     } uni;
  441.  
  442.     struct Guni {
  443.     int ii;
  444.     union {
  445.         unsigned bit1:1;
  446.         int j;
  447.         char c;
  448.     };
  449.     union {
  450.         unsigned bit2:1;
  451.         unsigned bit3:1;
  452.     };
  453.     };
  454.  
  455.     uni.ii   = 7;
  456.     uni.bit1 = 1;
  457.     uni.bit2 = 3;
  458.     uni.u.j  = 9;
  459.     uni.u.c  = 'a';
  460.  
  461.     Guni guni; 
  462.     guni.ii   = 1;
  463.     guni.j    = 2;
  464.     guni.c    = 'a';
  465.     guni.bit1 = 0;
  466.     guni.bit2 = 1;
  467.     guni.bit3 = 0;
  468.  
  469.     float pi       = 3.14159265358979323846;
  470.     double sqrt2   = 1.41421356237309504880;
  471.     signed char sc = 'a';
  472.  
  473.     guni.ii = int(pi * sqrt2 * sc);
  474. }
  475.  
  476. //--------------------------------------------------------------------------
  477. void cin_cout_test()
  478. {
  479.     // Simple I/O
  480.     char name[1024];
  481.     cout << "What's your name? ";
  482.     cin >> name;
  483.     cerr << "Hello, " << name << "!\n";
  484. }
  485.  
  486. //--------------------------------------------------------------------------
  487. int main(int /* argc */, char ** /* argv */)
  488. {
  489.     int i = 42;
  490.     tree_test();
  491.     i++;
  492.     list_test(i);
  493.     i++;
  494.     array_test();
  495.     i++;
  496.     plot_test();
  497.     i++;
  498.     type_test();
  499.     --i;
  500.     cin_cout_test();
  501.     return 0;
  502. }
  503.