Fix wrong configure test for abi::__forced_unwind in previous commit.

[wxWidgets.git] / demos / life / game.cpp

diff --git a/demos/life/game.cpp b/demos/life/game.cpp
index 46264b5238fc907a85e3b2b3b1695666f0e965a0..eefae2c2de69b581b3ea5ec35f2a552c15d95df9 100644 (file)
--- a/demos/life/game.cpp
+++ b/demos/life/game.cpp
@@ -9,18 +9,10 @@
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
 

-#ifdef __WIN16__
-#error "Sorry, Life! will not work in 16-bit Windows"
-#endif
-

 // ==========================================================================
 // headers, declarations, constants
 // ==========================================================================
 
 // ==========================================================================
 // headers, declarations, constants
 // ==========================================================================
 

-#ifdef __GNUG__
-    #pragma implementation "game.h"
-#endif
-

 // For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx/wx.h".
 #include "wx/wxprec.h"
 


@@ -39,7 +31,7 @@
 #include <string.h>           // for memset
 
 
 #include <string.h>           // for memset
 
 

-#define ARRAYSIZE  1024       // static array for BeginFind & co.
+#define CELLSARRAYSIZE  1024       // static array for BeginFind & co.

 #define ALLOCBOXES 16         // number of cellboxes to alloc at once
 #define MAXDEAD    8          // tics before removing cellbox from list
 
 #define ALLOCBOXES 16         // number of cellboxes to alloc at once
 #define MAXDEAD    8          // tics before removing cellbox from list
 


@@ -50,11 +42,11 @@
 
 #define HASH(x, y) (((x >> 3) & 0x7f) << 7) + ((y >> 3) & 0x7f)
 
 
 #define HASH(x, y) (((x >> 3) & 0x7f) << 7) + ((y >> 3) & 0x7f)
 

-#define HASHSIZE   32768      // hash table size (do not change!)
+#define HASHSIZE   16384      // hash table size (do not change!)

 #define CELLBOX    8          // cells in a cellbox (do not change!)
 
 
 #define CELLBOX    8          // cells in a cellbox (do not change!)
 
 

-class CellBox
+class LifeCellBox

 {
 public:
     // members
 {
 public:
     // members


@@ -62,33 +54,33 @@ public:
     inline bool SetCell(int dx, int dy, bool alive);
 
     // attributes
     inline bool SetCell(int dx, int dy, bool alive);
 
     // attributes

-    wxInt32   m_x, m_y;                     // position in universe
-    wxUint32  m_live1, m_live2;             // alive cells (1 bit per cell)
-    wxUint32  m_old1, m_old2;               // old values for m_live1, 2
-    wxUint32  m_on[8];                      // neighbouring info
-    wxUint32  m_dead;                       // been dead for n generations
-    CellBox  *m_up, *m_dn, *m_lf, *m_rt;    // neighbour CellBoxes
-    CellBox  *m_prev, *m_next;              // in linked list
-    CellBox  *m_hprev, *m_hnext;            // in hash table
+    wxInt32       m_x, m_y;                     // position in universe
+    wxUint32      m_live1, m_live2;             // alive cells (1 bit per cell)
+    wxUint32      m_old1, m_old2;               // old values for m_live1, 2
+    wxUint32      m_on[8];                      // neighbouring info
+    wxUint32      m_dead;                       // been dead for n generations
+    LifeCellBox  *m_up, *m_dn, *m_lf, *m_rt;    // neighbour CellBoxes
+    LifeCellBox  *m_prev, *m_next;              // in linked list
+    LifeCellBox  *m_hprev, *m_hnext;            // in hash table

 };
 
 
 // IsAlive:
 //  Returns whether cell dx, dy in this box is alive
 //
 };
 
 
 // IsAlive:
 //  Returns whether cell dx, dy in this box is alive
 //

-bool CellBox::IsAlive(int dx, int dy) const
+bool LifeCellBox::IsAlive(int dx, int dy) const

 {
     if (dy > 3)
 {
     if (dy > 3)

-        return (m_live2 & 1 << ((dy - 4) * 8 + dx));
+        return (m_live2 & 1 << ((dy - 4) * 8 + dx)) ? true : false ;

     else
     else

-        return (m_live1 & 1 << ((dy) * 8 + dx));
+        return (m_live1 & 1 << ((dy) * 8 + dx)) ? true : false ;

 }
 
 // SetCell:
 }
 
 // SetCell:

-//  Sets cell dx, dy in this box to 'alive', returns TRUE if
-//  the previous value was different, FALSE if it was the same.
+//  Sets cell dx, dy in this box to 'alive', returns true if
+//  the previous value was different, false if it was the same.

 //
 //

-bool CellBox::SetCell(int dx, int dy, bool alive)
+bool LifeCellBox::SetCell(int dx, int dy, bool alive)

 {
     if (IsAlive(dx, dy) != alive)
     {
 {
     if (IsAlive(dx, dy) != alive)
     {


@@ -100,10 +92,10 @@ bool CellBox::SetCell(int dx, int dy, bool alive)
        // reset this here to avoid updating problems
        m_dead = 0;
 
        // reset this here to avoid updating problems
        m_dead = 0;
 

-       return TRUE;
+       return true;

     }
     else
     }
     else

-       return FALSE;
+       return false;

 }
 
 
 }
 
 


@@ -118,23 +110,23 @@ bool CellBox::SetCell(int dx, int dy, bool alive)
 Life::Life()
 {
     // pattern description
 Life::Life()
 {
     // pattern description

-    m_name        = _("");
-    m_rules       = _("");
-    m_description = _("");
+    m_name        = wxEmptyString;
+    m_rules       = wxEmptyString;
+    m_description = wxEmptyString;

 
     // pattern data
     m_numcells    = 0;
 
     // pattern data
     m_numcells    = 0;

-    m_boxes       = new CellBox *[HASHSIZE];
+    m_boxes       = new LifeCellBox *[HASHSIZE];

     m_head        = NULL;
     m_available   = NULL;
     for (int i = 0; i < HASHSIZE; i++)
         m_boxes[i] = NULL;
 
     // state vars for BeginFind & FindMore
     m_head        = NULL;
     m_available   = NULL;
     for (int i = 0; i < HASHSIZE; i++)
         m_boxes[i] = NULL;
 
     // state vars for BeginFind & FindMore

-    m_cells       = new Cell[ARRAYSIZE];
+    m_cells       = new LifeCell[CELLSARRAYSIZE];

     m_ncells      = 0;
     m_ncells      = 0;

-    m_findmore    = FALSE;
-    m_changed     = FALSE;
+    m_findmore    = false;
+    m_changed     = false;

 }
 
 Life::~Life()
 }
 
 Life::~Life()


@@ -150,7 +142,7 @@ Life::~Life()
 //
 void Life::Clear()
 {
 //
 void Life::Clear()
 {

-    CellBox *c, *nc;
+    LifeCellBox *c, *nc;

 
     // clear the hash table pointers
     for (int i = 0; i < HASHSIZE; i++)
 
     // clear the hash table pointers
     for (int i = 0; i < HASHSIZE; i++)


@@ -177,9 +169,9 @@ void Life::Clear()
     m_available = NULL;
 
     // reset state
     m_available = NULL;
 
     // reset state

-    m_name        = _("");
-    m_rules       = _("");
-    m_description = _("");
+    m_name        = wxEmptyString;
+    m_rules       = wxEmptyString;
+    m_description = wxEmptyString;

     m_numcells    = 0;
 }
 
     m_numcells    = 0;
 }
 


@@ -192,7 +184,7 @@ void Life::Clear()
 //
 bool Life::IsAlive(wxInt32 x, wxInt32 y)
 {
 //
 bool Life::IsAlive(wxInt32 x, wxInt32 y)
 {

-    CellBox *c = LinkBox(x, y, FALSE);
+    LifeCellBox *c = LinkBox(x, y, false);

 
     return (c && c->IsAlive( x - c->m_x, y - c->m_y ));
 }
 
     return (c && c->IsAlive( x - c->m_x, y - c->m_y ));
 }


@@ -202,7 +194,7 @@ bool Life::IsAlive(wxInt32 x, wxInt32 y)
 //
 void Life::SetCell(wxInt32 x, wxInt32 y, bool alive)
 {
 //
 void Life::SetCell(wxInt32 x, wxInt32 y, bool alive)
 {

-    CellBox *c  = LinkBox(x, y);
+    LifeCellBox *c  = LinkBox(x, y);

     wxUint32 dx = x - c->m_x;
     wxUint32 dy = y - c->m_y;
 
     wxUint32 dx = x - c->m_x;
     wxUint32 dy = y - c->m_y;
 


@@ -257,15 +249,15 @@ void Life::SetPattern(const LifePattern& pattern)
 //  Creates a box in x, y, either taking it from the list
 //  of available boxes, or allocating a new one.
 //
 //  Creates a box in x, y, either taking it from the list
 //  of available boxes, or allocating a new one.
 //

-CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
+LifeCellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)

 {
 {

-    CellBox *c;
+    LifeCellBox *c;

 
     // if there are no available boxes, alloc a few more
     if (!m_available)
         for (int i = 1; i <= ALLOCBOXES; i++)
         {
 
     // if there are no available boxes, alloc a few more
     if (!m_available)
         for (int i = 1; i <= ALLOCBOXES; i++)
         {

-            c = new CellBox();
+            c = new LifeCellBox();

 
             if (!c)
             {
 
             if (!c)
             {


@@ -289,7 +281,7 @@ CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
     m_available = c->m_next;
 
     // reset everything
     m_available = c->m_next;
 
     // reset everything

-    memset((void *) c, 0, sizeof(CellBox));
+    memset((void *) c, 0, sizeof(LifeCellBox));

     c->m_x = x;
     c->m_y = y;
 
     c->m_x = x;
     c->m_y = y;
 


@@ -311,10 +303,10 @@ CellBox* Life::CreateBox(wxInt32 x, wxInt32 y, wxUint32 hv)
 //  it returns NULL or creates a new one, depending on the value
 //  of the 'create' parameter.
 //
 //  it returns NULL or creates a new one, depending on the value
 //  of the 'create' parameter.
 //

-CellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)
+LifeCellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)

 {
     wxUint32 hv;
 {
     wxUint32 hv;

-    CellBox *c;
+    LifeCellBox *c;

 
     x &= 0xfffffff8;
     y &= 0xfffffff8;
 
     x &= 0xfffffff8;
     y &= 0xfffffff8;


@@ -324,15 +316,15 @@ CellBox* Life::LinkBox(wxInt32 x, wxInt32 y, bool create)
     for (c = m_boxes[hv]; c; c = c->m_hnext)
         if ((c->m_x == x) && (c->m_y == y)) return c;
 
     for (c = m_boxes[hv]; c; c = c->m_hnext)
         if ((c->m_x == x) && (c->m_y == y)) return c;
 

-    // if not found, and (create == TRUE), create a new one
-    return create? CreateBox(x, y, hv) : (CellBox*) NULL;
+    // if not found, and (create == true), create a new one
+    return create? CreateBox(x, y, hv) : (LifeCellBox*) NULL;

 }
 
 // KillBox:
 //  Removes this box from the list and the hash table and
 //  puts it in the list of available boxes.
 //
 }
 
 // KillBox:
 //  Removes this box from the list and the hash table and
 //  puts it in the list of available boxes.
 //

-void Life::KillBox(CellBox *c)
+void Life::KillBox(LifeCellBox *c)

 {
     wxUint32 hv = HASH(c->m_x, c->m_y);
 
 {
     wxUint32 hv = HASH(c->m_x, c->m_y);
 


@@ -365,7 +357,7 @@ void Life::KillBox(CellBox *c)
 // Navigation
 // --------------------------------------------------------------------------
 
 // Navigation
 // --------------------------------------------------------------------------
 

-Cell Life::FindCenter()
+LifeCell Life::FindCenter()

 {
     double sx, sy;
     int n;
 {
     double sx, sy;
     int n;


@@ -373,7 +365,7 @@ Cell Life::FindCenter()
     sy = 0.0;
     n = 0;
 
     sy = 0.0;
     n = 0;
 

-    CellBox *c;
+    LifeCellBox *c;

     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead)
         {
     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead)
         {


@@ -388,87 +380,87 @@ Cell Life::FindCenter()
         sy = (sy / n) + CELLBOX / 2;
     }
 
         sy = (sy / n) + CELLBOX / 2;
     }
 

-    Cell cell;
+    LifeCell cell;

     cell.i = (wxInt32) sx;
     cell.j = (wxInt32) sy;
     return cell;
 }
 
     cell.i = (wxInt32) sx;
     cell.j = (wxInt32) sy;
     return cell;
 }
 

-Cell Life::FindNorth()
+LifeCell Life::FindNorth()

 {
     wxInt32 x = 0, y = 0;
 {
     wxInt32 x = 0, y = 0;

-    bool first = TRUE;
+    bool first = true;

 
 

-    CellBox *c;
+    LifeCellBox *c;

     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_y < y)))
         {
             x = c->m_x;
             y = c->m_y;
     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_y < y)))
         {
             x = c->m_x;
             y = c->m_y;

-            first = FALSE;
+            first = false;

         }
         }

-    
-    Cell cell;
+
+    LifeCell cell;

     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 
     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 

-Cell Life::FindSouth()
+LifeCell Life::FindSouth()

 {
     wxInt32 x = 0, y = 0;
 {
     wxInt32 x = 0, y = 0;

-    bool first = TRUE;
+    bool first = true;

 
 

-    CellBox *c;
+    LifeCellBox *c;

     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_y > y)))
         {
             x = c->m_x;
             y = c->m_y;
     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_y > y)))
         {
             x = c->m_x;
             y = c->m_y;

-            first = FALSE;
+            first = false;

         }
         }

-    
-    Cell cell;
+
+    LifeCell cell;

     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 
     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 

-Cell Life::FindWest()
+LifeCell Life::FindWest()

 {
     wxInt32 x = 0, y = 0;
 {
     wxInt32 x = 0, y = 0;

-    bool first = TRUE;
+    bool first = true;

 
 

-    CellBox *c;
+    LifeCellBox *c;

     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_x < x)))
         {
             x = c->m_x;
             y = c->m_y;
     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_x < x)))
         {
             x = c->m_x;
             y = c->m_y;

-            first = FALSE;
+            first = false;

         }
         }

-    
-    Cell cell;
+
+    LifeCell cell;

     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 
     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
 }
 

-Cell Life::FindEast()
+LifeCell Life::FindEast()

 {
     wxInt32 x = 0, y = 0;
 {
     wxInt32 x = 0, y = 0;

-    bool first = TRUE;
+    bool first = true;

 
 

-    CellBox *c;
+    LifeCellBox *c;

     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_x > x)))
         {
             x = c->m_x;
             y = c->m_y;
     for (c = m_head; c; c = c->m_next)
         if (!c->m_dead && ((first) || (c->m_x > x)))
         {
             x = c->m_x;
             y = c->m_y;

-            first = FALSE;
+            first = false;

         }
         }

-    
-    Cell cell;
+
+    LifeCell cell;

     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;
     cell.i = first? 0 : x + CELLBOX / 2;
     cell.j = first? 0 : y + CELLBOX / 2;
     return cell;


@@ -513,13 +505,13 @@ void Life::BeginFind(wxInt32 x0, wxInt32 y0, wxInt32 x1, wxInt32 y1, bool change
     m_x1 = (x1 + 7) & 0xfffffff8;
     m_y1 = (y1 + 7) & 0xfffffff8;
 
     m_x1 = (x1 + 7) & 0xfffffff8;
     m_y1 = (y1 + 7) & 0xfffffff8;
 

-    m_findmore = TRUE;
+    m_findmore = true;

     m_changed = changed;
 }
 
     m_changed = changed;
 }
 

-bool Life::FindMore(Cell *cells[], size_t *ncells)
+bool Life::FindMore(LifeCell *cells[], size_t *ncells)

 {
 {

-    CellBox *c;
+    LifeCellBox *c;

     *cells = m_cells;
     m_ncells = 0;
 
     *cells = m_cells;
     m_ncells = 0;
 


@@ -528,14 +520,14 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
         for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
             for ( ; m_x <= m_x1; m_x += 8)
             {
         for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
             for ( ; m_x <= m_x1; m_x += 8)
             {

-                if ((c = LinkBox(m_x, m_y, FALSE)) == NULL)
+                if ((c = LinkBox(m_x, m_y, false)) == NULL)

                     continue;
 
                 // check whether there is enough space left in the array
                     continue;
 
                 // check whether there is enough space left in the array

-                if (m_ncells > (ARRAYSIZE - 64))
+                if (m_ncells > (CELLSARRAYSIZE - 64))

                 {
                     *ncells = m_ncells;
                 {
                     *ncells = m_ncells;

-                    return FALSE;
+                    return false;

                 }
 
                 DoLine(m_x, m_y    , c->m_live1,       c->m_old1      );
                 }
 
                 DoLine(m_x, m_y    , c->m_live1,       c->m_old1      );


@@ -553,14 +545,14 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
         for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
             for ( ; m_x <= m_x1; m_x += 8)
             {
         for ( ; m_y <= m_y1; m_y += 8, m_x = m_x0)
             for ( ; m_x <= m_x1; m_x += 8)
             {

-                if ((c = LinkBox(m_x, m_y, FALSE)) == NULL)
+                if ((c = LinkBox(m_x, m_y, false)) == NULL)

                     continue;
 
                 // check whether there is enough space left in the array
                     continue;
 
                 // check whether there is enough space left in the array

-                if (m_ncells > (ARRAYSIZE - 64))
+                if (m_ncells > (CELLSARRAYSIZE - 64))

                 {
                     *ncells = m_ncells;
                 {
                     *ncells = m_ncells;

-                    return FALSE;
+                    return false;

                 }
 
                 DoLine(m_x, m_y    , c->m_live1      );
                 }
 
                 DoLine(m_x, m_y    , c->m_live1      );


@@ -575,8 +567,8 @@ bool Life::FindMore(Cell *cells[], size_t *ncells)
     }
 
     *ncells = m_ncells;
     }
 
     *ncells = m_ncells;

-    m_findmore = FALSE;
-    return TRUE;
+    m_findmore = false;
+    return true;

 }
 
 // --------------------------------------------------------------------------
 }
 
 // --------------------------------------------------------------------------


@@ -592,9 +584,9 @@ extern int g_tab2[];
 //
 bool Life::NextTic()
 {
 //
 bool Life::NextTic()
 {

-    CellBox  *c, *up, *dn, *lf, *rt;
+    LifeCellBox  *c, *up, *dn, *lf, *rt;

     wxUint32 t1, t2, t3, t4;
     wxUint32 t1, t2, t3, t4;

-    bool     changed = FALSE;
+    bool     changed = false;

 
     m_numcells = 0;
 
 
     m_numcells = 0;
 


@@ -874,17 +866,32 @@ bool Life::NextTic()
         t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 24) & 0xf) ] << 24;
         t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 28) & 0xf) ] << 28;
 
         t2 |= g_tab[ ((t4 & 0x0000ffff) << 4 ) + ((t3 >> 24) & 0xf) ] << 24;
         t2 |= g_tab[ ((t4 & 0xffff0000) >> 12) + ((t3 >> 28) & 0xf) ] << 28;
 

-        c->m_on[0] = c->m_on[1] = c->m_on[2] = c->m_on[3] = 
+        c->m_on[0] = c->m_on[1] = c->m_on[2] = c->m_on[3] =

         c->m_on[4] = c->m_on[5] = c->m_on[6] = c->m_on[7] = 0;
         c->m_live1 = t1;
         c->m_live2 = t2;
 
         c->m_on[4] = c->m_on[5] = c->m_on[6] = c->m_on[7] = 0;
         c->m_live1 = t1;
         c->m_live2 = t2;
 

-        // count alive cells (TODO: find a better way to do this)
+        // count alive cells
+#if 1
+        wxUint32 t1_, t2_;
+
+        t1_ = (t1  & 0x55555555) + (t1  >> 1 & 0x55555555);
+        t1_ = (t1_ & 0x33333333) + (t1_ >> 2 & 0x33333333);
+
+        t2_ = (t2  & 0x55555555) + (t2  >> 1 & 0x55555555);
+        t2_ = (t2_ & 0x33333333) + (t2_ >> 2 & 0x33333333) + t1_;
+        t2_ = (t2_ & 0x0F0F0F0F) + (t2_ >> 4 & 0x0F0F0F0F);
+        t2_ = (t2_ & 0x00FF00FF) + (t2_ >> 8 & 0x00FF00FF);
+
+        m_numcells += (t2_ & 0xFF) + (t2_ >> 16 & 0xFF);
+#else
+        // Original, slower code

         for (int i = 0; i < 32; i++)
         {
             if (t1 & (1 << i)) m_numcells++;
             if (t2 & (1 << i)) m_numcells++;
         }
         for (int i = 0; i < 32; i++)
         {
             if (t1 & (1 << i)) m_numcells++;
             if (t2 & (1 << i)) m_numcells++;
         }

+#endif

 
         changed |= ((t1 ^ c->m_old1) || (t2 ^ c->m_old2));
 
 
         changed |= ((t1 ^ c->m_old1) || (t2 ^ c->m_old2));
 


@@ -896,7 +903,7 @@ bool Life::NextTic()
         }
         else
         {
         }
         else
         {

-            CellBox *aux = c->m_next;
+            LifeCellBox *aux = c->m_next;

             if (c->m_dead++ > MAXDEAD)
                KillBox(c);
 
             if (c->m_dead++ > MAXDEAD)
                KillBox(c);
 


@@ -931,7 +938,7 @@ bool LifeModule::OnInit()
     // see below
     g_tab = new unsigned char [0xfffff];
 
     // see below
     g_tab = new unsigned char [0xfffff];
 

-    if (!g_tab) return FALSE;
+    if (!g_tab) return false;

 
     for (wxUint32 i = 0; i < 0xfffff; i++)
     {
 
     for (wxUint32 i = 0; i < 0xfffff; i++)
     {


@@ -953,7 +960,7 @@ bool LifeModule::OnInit()
         g_tab[i] = (unsigned char) live;
     }
 
         g_tab[i] = (unsigned char) live;
     }
 

-    return TRUE;
+    return true;

 }
 
 void LifeModule::OnExit()
 }
 
 void LifeModule::OnExit()


@@ -1125,7 +1132,7 @@ int g_tab1[]=
     0x11112110,
     0x11112121,
     0x11112221,
     0x11112110,
     0x11112121,
     0x11112221,

-    0x11112232,                        
+    0x11112232,

     0x11122100,
     0x11122111,
     0x11122211,
     0x11122100,
     0x11122111,
     0x11122211,