ncurses 6.0 - patch 20170930
[ncurses.git] / test / blue.c
index 4f7335132bbaa4bb4e94b85fe6c3b814dabdc811..9c4108a41a6a6d51717bc4ab8c747bfc136914b1 100644 (file)
@@ -1,3 +1,30 @@
+/****************************************************************************
+ * Copyright (c) 1998-2016,2017 Free Software Foundation, Inc.              *
+ *                                                                          *
+ * Permission is hereby granted, free of charge, to any person obtaining a  *
+ * copy of this software and associated documentation files (the            *
+ * "Software"), to deal in the Software without restriction, including      *
+ * without limitation the rights to use, copy, modify, merge, publish,      *
+ * distribute, distribute with modifications, sublicense, and/or sell       *
+ * copies of the Software, and to permit persons to whom the Software is    *
+ * furnished to do so, subject to the following conditions:                 *
+ *                                                                          *
+ * The above copyright notice and this permission notice shall be included  *
+ * in all copies or substantial portions of the Software.                   *
+ *                                                                          *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
+ * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
+ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
+ * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
+ * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
+ *                                                                          *
+ * Except as contained in this notice, the name(s) of the above copyright   *
+ * holders shall not be used in advertising or otherwise to promote the     *
+ * sale, use or other dealings in this Software without prior written       *
+ * authorization.                                                           *
+ ****************************************************************************/
 /*****************************************************************************
  *                                                                           *
  *                         B l u e   M o o n                                 *
  *****************************************************************************/
 
 /*
- * Compile this with the command `cc -O blue.c -lcurses -o blue'.  For best
- * results, use the ncurses(3) library.  On non-Intel machines, SVr4 curses is
- * just as good.
- *
- * $Id: blue.c,v 1.18 1999/01/17 00:11:56 tom Exp $
+ * $Id: blue.c,v 1.51 2017/09/30 17:43:18 tom Exp $
  */
 
 #include <test.priv.h>
 
-#include <string.h>
-#include <signal.h>
 #include <time.h>
 
-#include <term.h>
+#if HAVE_LANGINFO_CODESET
+#include <langinfo.h>
+#endif
 
 #define NOCARD         (-1)
 
@@ -47,7 +70,7 @@
 #define BLACK_ON_WHITE  2
 #define BLUE_ON_WHITE   3
 
-static RETSIGTYPE die(int onsig) GCC_NORETURN;
+static void die(int onsig) GCC_NORETURN;
 
 static int deck_size = PACK_SIZE;      /* initial deck */
 static int deck[PACK_SIZE];
@@ -55,7 +78,7 @@ static int deck[PACK_SIZE];
 static int grid[GRID_LENGTH];  /* card layout grid */
 static int freeptr[4];         /* free card space pointers */
 
-static int deal_number=0;
+static int deal_number = 0;
 
 static chtype ranks[SUIT_LENGTH][2] =
 {
@@ -74,354 +97,397 @@ static chtype ranks[SUIT_LENGTH][2] =
     {' ', 'K'}
 };
 
-/* Please note, that this is a bad example.
-   Color values should not be or'ed in. This
-   only works, because the characters used here
-   are plain and have no color attribute themselves. */
-#ifdef COLOR_PAIR
-#define OR_COLORS(value,pair) ((value) | COLOR_PAIR(pair))
-#else
-#define OR_COLORS(value,pair) (value)
-#endif
+static int letters[4] =
+{
+    'h',                       /* hearts */
+    's',                       /* spades */
+    'd',                       /* diamonds */
+    'c',                       /* clubs */
+};
 
-#define PC_COLORS(value,pair) (OR_COLORS(value,pair) | A_ALTCHARSET)
+#if HAVE_LANGINFO_CODESET
 
-static chtype letters[4] =
+#if HAVE_TIGETSTR
+static int glyphs[] =
 {
-    OR_COLORS('h', RED_ON_WHITE),      /* hearts */
-    OR_COLORS('s', BLACK_ON_WHITE),    /* spades */
-    OR_COLORS('d', RED_ON_WHITE),      /* diamonds */
-    OR_COLORS('c', BLACK_ON_WHITE),    /* clubs */
+    '\003',                    /* hearts */
+    '\006',                    /* spades */
+    '\004',                    /* diamonds */
+    '\005',                    /* clubs */
 };
+#endif
 
-#if defined(__i386__)
-static chtype glyphs[] =
+#if USE_WIDEC_SUPPORT
+static int uglyphs[] =
 {
-    PC_COLORS('\003', RED_ON_WHITE),   /* hearts */
-    PC_COLORS('\006', BLACK_ON_WHITE), /* spades */
-    PC_COLORS('\004', RED_ON_WHITE),   /* diamonds */
-    PC_COLORS('\005', BLACK_ON_WHITE), /* clubs */
+    0x2665,                    /* hearts */
+    0x2660,                    /* spades */
+    0x2666,                    /* diamonds */
+    0x2663                     /* clubs */
 };
-#endif /* __i386__ */
+#endif
+#endif /* HAVE_LANGINFO_CODESET */
 
-static chtype *suits = letters;        /* this may change to glyphs below */
+static int *suits = letters;   /* this may change to glyphs below */
 
-static RETSIGTYPE die(int onsig)
+static void
+die(int onsig)
 {
     (void) signal(onsig, SIG_IGN);
     endwin();
-    exit(EXIT_SUCCESS);
+    ExitProgram(EXIT_SUCCESS);
 }
 
-static void init_vars(void)
+static void
+init_vars(void)
 {
     int i;
 
     deck_size = PACK_SIZE;
-    for (i=0; i < PACK_SIZE; i++)
-       deck[i]=i;
+    for (i = 0; i < PACK_SIZE; i++)
+       deck[i] = i;
     for (i = 0; i < 4; i++)
-       freeptr[i]=i * GRID_WIDTH;
+       freeptr[i] = i * GRID_WIDTH;
 }
 
-static void shuffle(int size)
+static void
+shuffle(int size)
 {
-    int i,j,numswaps,swapnum,temp;
+    int i, j, numswaps, swapnum, temp;
 
-    numswaps=size*10;          /* an arbitrary figure */
+    numswaps = size * 10;      /* an arbitrary figure */
 
-    for (swapnum=0;swapnum<numswaps;swapnum++)
-    {
-       i=rand() % size;
-       j=rand() % size;
-       temp=deck[i];
-       deck[i]=deck[j];
-       deck[j]=temp;
+    for (swapnum = 0; swapnum < numswaps; swapnum++) {
+       i = rand() % size;
+       j = rand() % size;
+       temp = deck[i];
+       deck[i] = deck[j];
+       deck[j] = temp;
     }
 }
 
-static void deal_cards(void)
+static void
+deal_cards(void)
 {
-    int ptr, card=0, value, csuit, crank, suit, aces[4];
-
-    for (suit=HEARTS;suit<=CLUBS;suit++)
-    {
-       ptr=freeptr[suit];
-       grid[ptr++]=NOCARD;     /* 1st card space is blank */
-       while ((ptr % GRID_WIDTH) != 0)
-       {
-           value=deck[card++];
-           crank=value % SUIT_LENGTH;
-           csuit=value / SUIT_LENGTH;
-           if (crank==ACE)
-               aces[csuit]=ptr;
-           grid[ptr++]=value;
+    int ptr, card = 0, value, csuit, crank, suit, aces[4];
+
+    memset(aces, 0, sizeof(aces));
+    for (suit = HEARTS; suit <= CLUBS; suit++) {
+       ptr = freeptr[suit];
+       grid[ptr++] = NOCARD;   /* 1st card space is blank */
+       while ((ptr % GRID_WIDTH) != 0) {
+           value = deck[card++];
+           crank = value % SUIT_LENGTH;
+           csuit = value / SUIT_LENGTH;
+           if (crank == ACE)
+               aces[csuit] = ptr;
+           grid[ptr++] = value;
        }
     }
 
-    if (deal_number==1)                /* shift the aces down to the 1st column */
-       for (suit=HEARTS;suit<=CLUBS;suit++)
-       {
+    if (deal_number == 1)      /* shift the aces down to the 1st column */
+       for (suit = HEARTS; suit <= CLUBS; suit++) {
            grid[suit * GRID_WIDTH] = suit * SUIT_LENGTH;
-           grid[aces[suit]]=NOCARD;
-           freeptr[suit]=aces[suit];
+           grid[aces[suit]] = NOCARD;
+           freeptr[suit] = aces[suit];
        }
 }
 
-static void printcard(int value)
+static void
+printcard(int value)
 {
-    (void) addch(' ');
-    if (value == NOCARD)
+    AddCh(' ');
+    if (value == NOCARD) {
        (void) addstr("   ");
-    else
-    {
-       addch(ranks[value % SUIT_LENGTH][0] | COLOR_PAIR(BLUE_ON_WHITE));
-       addch(ranks[value % SUIT_LENGTH][1] | COLOR_PAIR(BLUE_ON_WHITE));
-       addch(suits[value / SUIT_LENGTH]);
+    } else {
+       int which = (value / SUIT_LENGTH);
+       int isuit = (value % SUIT_LENGTH);
+       chtype color = (chtype) COLOR_PAIR(((which % 2) == 0)
+                                          ? RED_ON_WHITE
+                                          : BLACK_ON_WHITE);
+
+       AddCh(ranks[isuit][0] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
+       AddCh(ranks[isuit][1] | (chtype) COLOR_PAIR(BLUE_ON_WHITE));
+
+#ifdef NCURSES_VERSION
+       (attron) ((int) color); /* quieter compiler warnings */
+#else
+       attron(color);          /* PDCurses, etc., either no macro or wrong */
+#endif
+#if USE_WIDEC_SUPPORT
+       {
+           wchar_t values[2];
+           values[0] = (wchar_t) suits[which];
+           values[1] = 0;
+           addwstr(values);
+       }
+#else
+       AddCh(suits[which]);
+#endif
+#ifdef NCURSES_VERSION
+       (attroff) ((int) color);
+#else
+       attroff(color);
+#endif
     }
-    (void) addch(' ');
+    AddCh(' ');
 }
 
-static void display_cards(int deal)
+static void
+display_cards(int deal)
 {
     int row, card;
 
     clear();
-    (void)printw(
-                "Blue Moon 2.1 - by Tim Lister & Eric Raymond - Deal %d.\n",
-                deal);
-    for(row=HEARTS;row<=CLUBS;row++)
-    {
+    (void) printw(
+                    "Blue Moon 2.1 - by Tim Lister & Eric Raymond - Deal %d.\n",
+                    deal);
+    for (row = HEARTS; row <= CLUBS; row++) {
        move(BASEROW + row + row + 2, 1);
-       for(card=0;card<GRID_WIDTH;card++)
+       for (card = 0; card < GRID_WIDTH; card++)
            printcard(grid[row * GRID_WIDTH + card]);
     }
 
-    move(PROMPTROW + 2, 0); refresh();
+    move(PROMPTROW + 2, 0);
+    refresh();
 #define P(x)   (void)printw("%s\n", x)
-P("   This 52-card solitaire starts with  the entire deck shuffled and dealt");
-P("out in four rows.  The aces are then moved to the left end of the layout,");
-P("making 4 initial free spaces.  You may move to a space only the card that");
-P("matches the left neighbor in suit, and is one greater in rank.  Kings are");
-P("high, so no cards may be placed to their right (they create dead spaces).");
-P("  When no moves can be made,  cards still out of sequence are  reshuffled");
-P("and dealt face up after the ends of the partial sequences, leaving a card");
-P("space after each sequence, so that each row looks like a partial sequence");
-P("followed by a space, followed by enough cards to make a row of 14.       ");
-P("  A moment's reflection will show that this game cannot take more than 13");
-P("deals. A good score is 1-3 deals, 4-7 is average, 8 or more is poor.     ");
+    P("   This 52-card solitaire starts with  the entire deck shuffled and dealt");
+    P("out in four rows.  The aces are then moved to the left end of the layout,");
+    P("making 4 initial free spaces.  You may move to a space only the card that");
+    P("matches the left neighbor in suit, and is one greater in rank.  Kings are");
+    P("high, so no cards may be placed to their right (they create dead spaces).");
+    P("  When no moves can be made,  cards still out of sequence are  reshuffled");
+    P("and dealt face up after the ends of the partial sequences, leaving a card");
+    P("space after each sequence, so that each row looks like a partial sequence");
+    P("followed by a space, followed by enough cards to make a row of 14.       ");
+    P("  A moment's reflection will show that this game cannot take more than 13");
+    P("deals. A good score is 1-3 deals, 4-7 is average, 8 or more is poor.     ");
 #undef P
     refresh();
 }
 
-static int find(int card)
+static int
+find(int card)
 {
     int i;
 
-    if ((card<0) || (card>=PACK_SIZE))
-       return(NOCARD);
-    for(i = 0; i < GRID_LENGTH; i++)
+    if ((card < 0) || (card >= PACK_SIZE))
+       return (NOCARD);
+    for (i = 0; i < GRID_LENGTH; i++)
        if (grid[i] == card)
            return i;
-    return(NOCARD);
+    return (NOCARD);
 }
 
-static void movecard(int src, int dst)
+static void
+movecard(int src, int dst)
 {
-    grid[dst]=grid[src];
-    grid[src]=NOCARD;
+    grid[dst] = grid[src];
+    grid[src] = NOCARD;
 
-    move( BASEROW + (dst / GRID_WIDTH)*2+2, (dst % GRID_WIDTH)*5 + 1);
+    move(BASEROW + (dst / GRID_WIDTH) * 2 + 2, (dst % GRID_WIDTH) * 5 + 1);
     printcard(grid[dst]);
 
-    move( BASEROW + (src / GRID_WIDTH)*2+2, (src % GRID_WIDTH)*5 + 1);
+    move(BASEROW + (src / GRID_WIDTH) * 2 + 2, (src % GRID_WIDTH) * 5 + 1);
     printcard(grid[src]);
 
     refresh();
 }
 
-static void play_game(void)
+static void
+play_game(void)
 {
-    int dead=0, i, j;
+    int dead = 0, i, j;
     char c;
     int selection[4], card;
 
-    while (dead<4)
-    {
-       dead=0;
-       for (i=0;i<4;i++)
-       {
-           card=grid[freeptr[i]-1];
+    while (dead < 4) {
+       dead = 0;
+       for (i = 0; i < 4; i++) {
+           card = grid[freeptr[i] - 1];
 
-           if (        ((card % SUIT_LENGTH)==KING)
+           if (((card % SUIT_LENGTH) == KING)
                ||
-               (card==NOCARD)  )
-               selection[i]=NOCARD;
+               (card == NOCARD))
+               selection[i] = NOCARD;
            else
-               selection[i]=find(card+1);
+               selection[i] = find(card + 1);
 
-           if (selection[i]==NOCARD)
+           if (selection[i] == NOCARD)
                dead++;
        };
 
-       if (dead < 4)
-       {
-           char        live[NSUITS+1], *lp = live;
-
-           for (i=0;i<4;i++)
-           {
-               if (selection[i] != NOCARD)
-               {
-                   move(BASEROW + (selection[i] / GRID_WIDTH)*2+3,
-                        (selection[i] % GRID_WIDTH)*5);
-                   (void)printw("   %c ", *lp++ = 'a' + i);
+       if (dead < 4) {
+           char live[NSUITS + 1], *lp = live;
+
+           for (i = 0; i < 4; i++) {
+               if (selection[i] != NOCARD) {
+                   move(BASEROW + (selection[i] / GRID_WIDTH) * 2 + 3,
+                        (selection[i] % GRID_WIDTH) * 5);
+                   (void) printw("   %c ", (*lp++ = (char) ('a' + i)));
                }
            };
            *lp = '\0';
 
-           if (strlen(live) == 1)
-           {
-               move(PROMPTROW,0);
-               (void)printw(
-                   "Making forced moves...                                 ");
+           if (strlen(live) == 1) {
+               move(PROMPTROW, 0);
+               (void) printw(
+                                "Making forced moves...                                 ");
                refresh();
                (void) sleep(1);
                c = live[0];
-           }
-           else
-           {
-               char    buf[BUFSIZ];
+           } else {
+               char buf[BUFSIZ];
 
-               (void)sprintf(buf,
-                       "Type [%s] to move, r to redraw, q or INTR to quit: ",
-                       live);
+               _nc_SPRINTF(buf, _nc_SLIMIT(sizeof(buf))
+                           "Type [%s] to move, r to redraw, q or INTR to quit: ",
+                           live);
 
                do {
-                   move(PROMPTROW,0);
+                   move(PROMPTROW, 0);
                    (void) addstr(buf);
-                   move(PROMPTROW, (int)strlen(buf));
+                   move(PROMPTROW, (int) strlen(buf));
                    clrtoeol();
-                   (void) addch(' ');
+                   AddCh(' ');
                } while
-                   (((c = getch())<'a' || c>'d') && (c!='r') && (c!='q'));
+                   (((c = (char) getch()) < 'a' || c > 'd')
+                    && (c != 'r')
+                    && (c != 'q'));
            }
 
            for (j = 0; j < 4; j++)
-               if (selection[j]!=NOCARD)
-               {
-                   move(BASEROW + (selection[j] / GRID_WIDTH)*2+3,
-                        (selection[j] % GRID_WIDTH)*5);
-                   (void)printw("     ");
+               if (selection[j] != NOCARD) {
+                   move(BASEROW + (selection[j] / GRID_WIDTH) * 2 + 3,
+                        (selection[j] % GRID_WIDTH) * 5);
+                   (void) printw("     ");
                }
 
            if (c == 'r')
                display_cards(deal_number);
            else if (c == 'q')
                die(SIGINT);
-           else
-           {
-               i = c-'a';
+           else {
+               i = c - 'a';
                if (selection[i] == NOCARD)
                    beep();
-               else
-               {
+               else {
                    movecard(selection[i], freeptr[i]);
-                   freeptr[i]=selection[i];
+                   freeptr[i] = selection[i];
                }
            }
        }
     }
 
     move(PROMPTROW, 0);
-    standout();
-    (void)printw("Finished deal %d - type any character to continue...", deal_number);
-    standend();
+    (void) standout();
+    (void) printw("Finished deal %d - type any character to continue...", deal_number);
+    (void) standend();
     (void) getch();
 }
 
-static int collect_discards(void)
+static int
+collect_discards(void)
 {
-    int row, col, cardno=0, finish, gridno;
+    int row, col, cardno = 0, finish, gridno;
 
-    for (row=HEARTS;row<=CLUBS;row++)
-    {
-       finish=0;
-       for (col=1;col<GRID_WIDTH;col++)
-       {
-           gridno=row * GRID_WIDTH + col;
+    for (row = HEARTS; row <= CLUBS; row++) {
+       finish = 0;
+       for (col = 1; col < GRID_WIDTH; col++) {
+           gridno = row * GRID_WIDTH + col;
 
-           if ((grid[gridno]!=(grid[gridno-1]+1))&&(finish==0))
-           {
-               finish=1;
-               freeptr[row]=gridno;
+           if ((grid[gridno] != (grid[gridno - 1] + 1)) && (finish == 0)) {
+               finish = 1;
+               freeptr[row] = gridno;
            };
 
-           if ((finish!=0)&&(grid[gridno]!=NOCARD))
-               deck[cardno++]=grid[gridno];
+           if ((finish != 0) && (grid[gridno] != NOCARD))
+               deck[cardno++] = grid[gridno];
        }
     }
     return cardno;
 }
 
-static void game_finished(int deal)
+static void
+game_finished(int deal)
 {
     clear();
-    (void)printw("You finished the game in %d deals. This is ",deal);
-    standout();
-    if (deal<2)
-       (void)addstr("excellent");
-    else if (deal<4)
-       (void)addstr("good");
-    else if (deal<8)
-       (void)addstr("average");
+    (void) printw("You finished the game in %d deals. This is ", deal);
+    (void) standout();
+    if (deal < 2)
+       (void) addstr("excellent");
+    else if (deal < 4)
+       (void) addstr("good");
+    else if (deal < 8)
+       (void) addstr("average");
     else
-       (void)addstr("poor");
-    standend();
+       (void) addstr("poor");
+    (void) standend();
     (void) addstr(".         ");
     refresh();
 }
 
-int main(int argc, char *argv[])
+#if HAVE_LANGINFO_CODESET
+/*
+ * This program first appeared in ncurses in January 1995.  At that point, the
+ * Linux console was able to display CP437 graphic characters, e.g., in the
+ * range 0-31.  As of 2016, most Linux consoles are running with the UTF-8
+ * (partial) support.  Incidentally, that makes all of the cards diamonds.
+ */
+static void
+use_pc_display(void)
 {
-    (void) signal(SIGINT, die);
-    initscr();
-
-    /*
-     * We use COLOR_GREEN because COLOR_BLACK is wired to the wrong thing.
-     */
-    start_color();
-    init_pair(RED_ON_WHITE,    COLOR_RED,   COLOR_WHITE);
-    init_pair(BLUE_ON_WHITE,   COLOR_BLUE,  COLOR_WHITE);
-    init_pair(BLACK_ON_WHITE,  COLOR_BLACK, COLOR_WHITE);
-
-#ifndef COLOR_PAIR
-    letters[0] = OR_COLORS('h', RED_ON_WHITE);         /* hearts */
-    letters[1] = OR_COLORS('s', BLACK_ON_WHITE);       /* spades */
-    letters[2] = OR_COLORS('d', RED_ON_WHITE);         /* diamonds */
-    letters[3] = OR_COLORS('c', BLACK_ON_WHITE);       /* clubs */
-#if defined(__i386__) && defined(A_ALTCHARSET)
-    glyphs[0]  = PC_COLORS('\003', RED_ON_WHITE);      /* hearts */
-    glyphs[1]  = PC_COLORS('\006', BLACK_ON_WHITE);    /* spades */
-    glyphs[2]  = PC_COLORS('\004', RED_ON_WHITE);      /* diamonds */
-    glyphs[3]  = PC_COLORS('\005', BLACK_ON_WHITE);    /* clubs */
+    char *check = nl_langinfo(CODESET);
+    if (!strcmp(check, "UTF-8")) {
+#if USE_WIDEC_SUPPORT
+       suits = uglyphs;
 #endif
+    } else {
+#if HAVE_TIGETSTR
+       if (!strcmp(check, "IBM437") ||
+           !strcmp(check, "CP437") ||
+           !strcmp(check, "IBM850") ||
+           !strcmp(check, "CP850")) {
+           char *smacs = tigetstr("smacs");
+           char *smpch = tigetstr("smpch");
+           /*
+            * The ncurses library makes this check to decide whether to allow
+            * the alternate character set for the (normally) nonprinting codes.
+            */
+           if (smacs != 0 && smpch != 0 && !strcmp(smacs, smpch)) {
+               suits = glyphs;
+           }
+       }
 #endif
+    }
+}
+#else
+#define use_pc_display()       /* nothing */
+#endif /* HAVE_LANGINFO_CODESET */
 
-#if defined(__i386__) && defined(A_ALTCHARSET)
-    if (tigetstr("smpch"))
-       suits = glyphs;
-#endif /* __i386__ && A_ALTCHARSET */
+int
+main(int argc, char *argv[])
+{
+    setlocale(LC_ALL, "");
+
+    use_pc_display();
+
+    InitAndCatch(initscr(), die);
+
+    start_color();
+    init_pair(RED_ON_WHITE, COLOR_RED, COLOR_WHITE);
+    init_pair(BLUE_ON_WHITE, COLOR_BLUE, COLOR_WHITE);
+    init_pair(BLACK_ON_WHITE, COLOR_BLACK, COLOR_WHITE);
 
     cbreak();
 
     if (argc == 2)
-       srand((unsigned)atoi(argv[1]));
+       srand((unsigned) atoi(argv[1]));
     else
-       srand((unsigned)time((time_t *)0));
+       srand((unsigned) time((time_t *) 0));
 
     init_vars();
 
-    do{
+    do {
        deal_number++;
        shuffle(deck_size);
        deal_cards();
@@ -429,12 +495,12 @@ int main(int argc, char *argv[])
        play_game();
     }
     while
-       ((deck_size=collect_discards()) != 0);
+       ((deck_size = collect_discards()) != 0);
 
     game_finished(deal_number);
 
     die(SIGINT);
-    /*NOTREACHED*/
+    /*NOTREACHED */
 }
 
 /* blue.c ends here */