-WARNS6 cleanup (1858 warnings)
authorPeter Avalos <pavalos@dragonflybsd.org>
Tue, 8 Aug 2006 16:36:11 +0000 (16:36 +0000)
committerPeter Avalos <pavalos@dragonflybsd.org>
Tue, 8 Aug 2006 16:36:11 +0000 (16:36 +0000)
-ANSI function declarations
-staticize functions
-Change if(x = foo(y)) constructs to if((x = foo(y)) != 0)
-Add $DragonFly$ where needed

22 files changed:
games/backgammon/backgammon/Makefile
games/backgammon/backgammon/extra.c
games/backgammon/backgammon/main.c
games/backgammon/backgammon/move.c
games/backgammon/backgammon/text.c
games/backgammon/common_source/allow.c
games/backgammon/common_source/back.h
games/backgammon/common_source/board.c
games/backgammon/common_source/check.c
games/backgammon/common_source/fancy.c
games/backgammon/common_source/odds.c
games/backgammon/common_source/one.c
games/backgammon/common_source/save.c
games/backgammon/common_source/subs.c
games/backgammon/common_source/table.c
games/backgammon/teachgammon/Makefile
games/backgammon/teachgammon/data.c
games/backgammon/teachgammon/teach.c
games/backgammon/teachgammon/ttext1.c
games/backgammon/teachgammon/ttext2.c
games/backgammon/teachgammon/tutor.c
games/backgammon/teachgammon/tutor.h

index 8c1c8ce..db89fb9 100644 (file)
@@ -1,16 +1,17 @@
 #      @(#)Makefile    8.1 (Berkeley) 5/31/93
 # $FreeBSD: src/games/backgammon/backgammon/Makefile,v 1.2.14.1 2001/04/25 09:28:44 ru Exp $
-# $DragonFly: src/games/backgammon/backgammon/Makefile,v 1.2 2003/06/17 04:25:22 dillon Exp $
+# $DragonFly: src/games/backgammon/backgammon/Makefile,v 1.3 2006/08/08 16:36:11 pavalos Exp $
 
 PROG=  backgammon
 CFLAGS+=-DV7 -I${.CURDIR}/../common_source
 SRCS=  allow.c board.c check.c extra.c fancy.c init.c main.c move.c \
        odds.c one.c save.c subs.c table.c text.c version.c
 MAN=   backgammon.6
-DPADD= ${LIBTERMCAP} ${LIBCOMPAT}
-LDADD= -ltermcap -lcompat
+DPADD= ${LIBTERMCAP}
+LDADD= -ltermcap
 .PATH: ${.CURDIR}/../common_source
 HIDEGAME=hidegame
+WARNS?=        6
 
 .include "../../Makefile.inc"
 .include <bsd.prog.mk>
index 7093b61..a9a044e 100644 (file)
@@ -32,7 +32,7 @@
  *
  * @(#)extra.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/backgammon/extra.c,v 1.4 1999/11/30 03:48:22 billf Exp $
- * $DragonFly: src/games/backgammon/backgammon/extra.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/backgammon/extra.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 FILE   *trace;
 #endif
 
+static int     eval(void);
+
 /*
  * dble()
  *     Have the current player double and ask opponent to accept.
  */
 
-dble ()  {
+void
+dble(void)
+{
        int     resp;                   /* response to y/n */
 
        for (;;)  {
@@ -100,7 +104,7 @@ dble ()  {
                return;
        }
 }
-\f
+
 /*
  * dblgood ()
  *     Returns 1 if the computer would double in this position.  This
@@ -112,7 +116,9 @@ dble ()  {
  * behind.
  */
 
-dblgood ()  {
+int
+dblgood(void)
+{
        int     n;                      /* accumulated judgment */
        int     OFFC = *offptr;         /* no. of computer's men off */
        int     OFFO = *offopp;         /* no. of player's men off */
@@ -186,10 +192,9 @@ dblgood ()  {
                return(1);
        return (0);
 }
-\f
-freemen (b)
-int    b;
 
+int
+freemen(int b)
 {
        int             i, inc, lim;
 
@@ -205,10 +210,9 @@ int        b;
                return ((36-count())/5);
        return (count()/5);
 }
-\f
-trapped (n,inc)
-int    n, inc;
 
+int
+trapped(int n, int inc)
 {
        int             i, j, k;
        int             c, l, ct;
@@ -232,9 +236,10 @@ int        n, inc;
        }
        return (ct/5);
 }
-\f
-eval ()  {
 
+static int
+eval(void)
+{
        int             i, j;
 
        for (j = i = 0; i < 26; i++)
index 1c38096..4791faf 100644 (file)
  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
  * @(#)main.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/backgammon/main.c,v 1.13 1999/11/30 03:48:22 billf Exp $
- * $DragonFly: src/games/backgammon/backgammon/main.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/backgammon/main.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <stdio.h>
-#include <unistd.h>
 #include <string.h>
-#include <stdlib.h>
 #include <signal.h>
 #include "back.h"
 
@@ -48,7 +46,6 @@
 
 extern const char      *const instr[];         /* text of instructions */
 extern const char      *const message[];       /* update message */
-char   ospeed;                                 /* tty output speed */
 
 const char     *helpm[] = {                    /* help message */
        "Enter a space or newline to roll, or",
@@ -84,10 +81,8 @@ static const char    svpromt[] = "Would you like to save this game?";
 static const char      password[] = "losfurng";
 static char    pbuf[10];
 
-main (argc,argv)
-int    argc;
-char   **argv;
-
+int
+main(int argc, char **argv)
 {
        int     i;              /* non-descript index */
        int     l;              /* non-descript index */
@@ -99,8 +94,8 @@ char  **argv;
        /* initialization */
        bflag = 2;                                      /* default no board */
        acnt = 1;                                       /* Nuber of args */
-       signal (SIGINT,getout);                         /* trap interrupts */
-       if (gtty (0,&tty) == -1)                        /* get old tty mode */
+       signal (SIGINT,(sig_t)getout);                  /* trap interrupts */
+       if (ioctl(0, TIOCGETP, &tty) == -1)             /* get old tty mode */
                errexit ("backgammon(gtty)");
        old = tty.sg_flags;
 #ifdef V7
@@ -108,7 +103,6 @@ char        **argv;
 #else
        raw = ((noech = old & ~ECHO) | RAW);            /* set up modes */
 #endif
-       ospeed = tty.sg_ospeed;                         /* for termlib */
 
                                                        /* get terminal
                                                         * capabilities, and
@@ -133,7 +127,7 @@ char        **argv;
                                                        /* check if restored
                                                         * game and save flag
                                                         * for later */
-       if (rfl = rflag)  {
+       if ((rfl = rflag) != 0)  {
                text (message);                         /* print message */
                text (contin);
                wrboard();                              /* print board */
@@ -200,7 +194,7 @@ char        **argv;
                                        else
                                                writec ('\n');
                                        writel ("Password:");
-                                       signal (SIGALRM,getout);
+                                       signal (SIGALRM,(sig_t)getout);
                                        cflag = 1;
                                        alarm (10);
                                        for (i = 0; i < 10; i++)  {
@@ -559,4 +553,6 @@ char        **argv;
 
                                                        /* leave peacefully */
        getout ();
+       /* NOTREACHED */
+       return(0);
 }
index 41683fb..4b78be8 100644 (file)
  *
  * @(#)move.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/backgammon/move.c,v 1.5 1999/11/30 03:48:23 billf Exp $
- * $DragonFly: src/games/backgammon/backgammon/move.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/backgammon/move.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
-#include <stdlib.h>
 #include "back.h"
 
 #ifdef DEBUG
@@ -44,6 +43,18 @@ FILE *trace;
 static char    tests[20];
 #endif
 
+static void             trymove(int, int);
+static struct BOARD    *bsave(void);
+static void             binsert(struct BOARD *);
+static int              bcomp(struct BOARD *, struct BOARD *);
+static void             mvcheck(struct BOARD *, struct BOARD *);
+static void             makefree(struct BOARD *);
+static struct BOARD    *nextfree(void);
+static void             pickmove(void);
+static void             boardcopy(struct BOARD *);
+static void             movcmp(void);
+static int              movegood(void);
+
 struct BOARD  {                                /* structure of game position */
        int     b_board[26];                    /* board position */
        int     b_in[2];                        /* men in */
@@ -55,8 +66,6 @@ struct BOARD  {                               /* structure of game position */
 
 struct BOARD *freeq = 0;
 struct BOARD *checkq = 0;
-struct BOARD *bsave();
-struct BOARD *nextfree();
 
                                        /* these variables are values for the
                                         * candidate move */
@@ -83,13 +92,14 @@ static int  cp[5];                          /* candidate start position */
 static int     cg[5];                          /* candidate finish position */
 
 static int     race;                           /* game reduced to a race */
-\f
-move (okay)
-int    okay;                                   /* zero if first move */
+
+void
+move(int okay)
 {
        int     i;              /* index */
-       int     l;              /* last man */
+       int     l = 0;          /* last man */
 
+       /* first move? */
        if (okay)  {
                                                /* see if comp should double */
                if (gvalue < 64 && dlast != cturn && dblgood())  {
@@ -173,11 +183,13 @@ int       okay;                                   /* zero if first move */
        }
        fixtty (raw);                           /* no more tty interrupt */
 }
-\f
-trymove (mvnum,swapped)
-int            mvnum;                          /* number of move (rel zero) */
-int            swapped;                        /* see if swapped also tested */
 
+/*
+ * mvnum is number of move (rel zero)
+ * see if swapped also tested
+ */
+static void
+trymove(int mvnum, int swapped)
 {
        int     pos;                    /* position on board */
        int     rval;                   /* value of roll */
@@ -228,9 +240,10 @@ int                swapped;                        /* see if swapped also tested */
        if ((!swapped) && D0 != D1)
                trymove (0,1);
 }
-\f
-struct BOARD *
-bsave ()  {
+
+static struct BOARD *
+bsave(void)
+{
        int             i;              /* index */
        struct BOARD    *now;           /* current position */
 
@@ -249,53 +262,52 @@ bsave ()  {
        }
        return (now);
 }
-\f
-binsert (new)
-struct BOARD   *new;                                   /* item to insert */
+
+static void
+binsert(struct BOARD *new)
 {
-       struct BOARD    *p = checkq;            /* queue pointer */
+       struct BOARD    *qp = checkq;           /* queue pointer */
        int             result;                 /* comparison result */
 
-       if (p == 0)  {                          /* check if queue empty */
-               checkq = p = new;
-               p->b_next = 0;
+       if (qp == 0)  {                         /* check if queue empty */
+               checkq = qp = new;
+               qp->b_next = 0;
                return;
        }
 
-       result = bcomp (new,p);                 /* compare to first element */
+       result = bcomp (new,qp);                /* compare to first element */
        if (result < 0)  {                              /* insert in front */
-               new->b_next = p;
+               new->b_next = qp;
                checkq = new;
                return;
        }
        if (result == 0)  {                             /* duplicate entry */
-               mvcheck (p,new);
+               mvcheck (qp,new);
                makefree (new);
                return;
        }
 
-       while (p->b_next != 0)  {               /* traverse queue */
-               result = bcomp (new,p->b_next);
+       while (qp->b_next != 0)  {              /* traverse queue */
+               result = bcomp (new,qp->b_next);
                if (result < 0)  {                      /* found place */
-                       new->b_next = p->b_next;
-                       p->b_next = new;
+                       new->b_next = qp->b_next;
+                       qp->b_next = new;
                        return;
                }
                if (result == 0)  {                     /* duplicate entry */
-                       mvcheck (p->b_next,new);
+                       mvcheck (qp->b_next,new);
                        makefree (new);
                        return;
                }
-               p = p->b_next;
+               qp = qp->b_next;
        }
                                                /* place at end of queue */
-       p->b_next = new;
+       qp->b_next = new;
        new->b_next = 0;
 }
-\f
-bcomp (a,b)
-struct BOARD   *a;
-struct BOARD   *b;
+
+static int
+bcomp(struct BOARD *a, struct BOARD *b)
 {
        int     *aloc = a->b_board;     /* pointer to board a */
        int     *bloc = b->b_board;     /* pointer to board b */
@@ -309,10 +321,9 @@ struct BOARD       *b;
        }
        return (0);                             /* same position */
 }
-\f
-mvcheck (incumbent,candidate)
-struct BOARD   *incumbent;
-struct BOARD   *candidate;
+
+static void
+mvcheck(struct BOARD *incumbent, struct BOARD *candidate)
 {
        int             i;
        int             result;
@@ -331,16 +342,17 @@ struct BOARD      *candidate;
                incumbent->b_fn[i] = candidate->b_fn[i];
        }
 }
-\f
-makefree (dead)
-struct BOARD   *dead;                  /* dead position */
+
+static void
+makefree(struct BOARD *dead)
 {
        dead->b_next = freeq;                   /* add to freeq */
        freeq = dead;
 }
 
-struct BOARD *
-nextfree ()  {
+static struct BOARD *
+nextfree(void)
+{
        struct BOARD    *new;
 
        if (freeq == 0)  {
@@ -356,8 +368,10 @@ nextfree ()  {
        }
        return (new);
 }
-\f
-pickmove ()  {
+
+static void
+pickmove(void)
+{
                                                /* current game position */
        struct BOARD    *now = bsave();
        struct BOARD    *next;          /* next move */
@@ -378,9 +392,9 @@ pickmove ()  {
 
        boardcopy (now);
 }
-\f
-boardcopy (s)
-struct BOARD   *s;                     /* game situation */
+
+static void
+boardcopy(struct BOARD *s)
 {
        int     i;                      /* index */
 
@@ -395,10 +409,11 @@ struct BOARD      *s;                     /* game situation */
                g[i] = s->b_fn[i];
        }
 }
-\f
-movcmp ()  {
+
+static void
+movcmp(void)
+{
        int     i;
-       int     c;
 
 #ifdef DEBUG
        if (trace == NULL)
@@ -468,8 +483,10 @@ movcmp ()  {
        }
 #endif
 }
-\f
-movegood ()  {
+
+static int
+movegood(void)
+{
        int     n;
 
        if (*offptr == 15)
index 88e93ff..0a7d750 100644 (file)
@@ -32,7 +32,7 @@
  *
  * @(#)text.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/backgammon/text.c,v 1.5 1999/11/30 03:48:23 billf Exp $
- * $DragonFly: src/games/backgammon/backgammon/text.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/backgammon/text.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
@@ -102,12 +102,9 @@ const char *const instr[] = {
     "    Now you should be ready to begin the game.  Good luck!",
     "",
     0};
-\f
-
-int
-text (t)
-const char     *const *t;
 
+void
+text(const char *const *t)
 {
        int             i;
        const char      *s, *a;
index b7eab9e..ca89404 100644 (file)
  *
  * @(#)allow.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/allow.c,v 1.4 1999/11/30 03:48:24 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/allow.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/allow.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 
-movallow ()  {
+int
+movallow(void)
+{
 
        int             i, m, iold;
        int             r;
@@ -57,7 +59,7 @@ movallow ()  {
                                g[i] = bar+cturn*D1;
                        else
                                g[i] = bar+cturn*D0;
-                       if (r = makmove(i))  {
+                       if ((r = makmove(i)) != 0)  {
                                if (d0 || m == 4)
                                        break;
                                swap;
index 88ca933..7b946be 100644 (file)
  * SUCH DAMAGE.
  *
  *     @(#)back.h      8.1 (Berkeley) 5/31/93
+ * $DragonFly: src/games/backgammon/common_source/back.h,v 1.2 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <sgtty.h>
+#include <stdlib.h>
+#include <unistd.h>
 
 #define rnum(r)        (random()%r)
 #define D0     dice[0]
@@ -124,4 +127,66 @@ extern int curc;           /* column position of cursor */
 extern int     begscr;         /* 'beginning' of screen
                                   (not including board) */
 
-void   getout();               /* function to exit backgammon cleanly */
+int    movallow(void);
+
+void   wrboard(void);
+
+void   getmove(void);
+int    movokay(int);
+
+void   fboard(void);
+void   refresh(void);
+void   curmove(int, int);
+void   newpos(void);
+void   clear(void);
+void   fancyc(char);
+void   clend(void);
+void   cline(void);
+int    getcaps(const char *);
+
+void   odds(int, int, int);
+int    count(void);
+int    canhit(int, int);
+
+int    makmove(int);
+void   moverr(int);
+void   movback(int);
+void   backone(int);
+
+void   save(int);
+void   recover(const char *);
+
+void   errexit(const char *);
+int    addbuf(int);
+void   buflush(void);
+char   readc(void);
+void   writec(char);
+void   writel(const char *);
+void   proll(void);
+void   wrint(int);
+void   gwrite(void);
+int    quit(void);
+int    yorn(char);
+void   wrhit(int);
+void   nexturn(void);
+void   getarg(int, char **);
+void   init(void);
+void   wrscore(void);
+void   fixtty(int);
+void   getout(void);           /* function to exit backgammon cleanly */
+void   roll(void);
+
+int    checkmove(int);
+
+void   dble(void);
+int    dblgood(void);
+int    freemen(int);
+int    trapped(int, int);
+
+void   move(int);
+
+#ifdef TEACHGAMMON_TEXT
+int    text(const char *const *);
+#else
+void   text(const char *const *);
+#endif
index 8156690..ef71c59 100644 (file)
  *
  * @(#)board.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/board.c,v 1.6 1999/11/30 03:48:25 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/board.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/board.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <string.h>
 #include "back.h"
 
+static void    wrbsub(void);
+
 static int     i, j, k;
 static char    ln[60];
 
-wrboard ()  {
+void
+wrboard(void)
+{
        int     l;
        static const char       bl[] =
                "|                       |   |                       |\n";
@@ -156,8 +160,10 @@ lastline:
        }
        fixtty(raw);
 }
-\f
-wrbsub () {
+
+static void
+wrbsub(void)
+{
        int             m;
        char            d;
 
index f72a309..f75a040 100644 (file)
  *
  * @(#)check.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/check.c,v 1.4 1999/11/30 03:48:25 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/check.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/check.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 
-getmove ()  {
+void
+getmove(void)
+{
        int     i, c;
 
        c = 0;
@@ -99,10 +101,9 @@ getmove ()  {
                }
        }
 }
-\f
-movokay (mv)
-int    mv;
 
+int
+movokay(int mv)
 {
        int     i, m;
 
index 09b3e84..3f70c1f 100644 (file)
  *
  * @(#)fancy.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/fancy.c,v 1.7 1999/11/30 03:48:25 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/fancy.c,v 1.3 2003/11/12 14:53:52 eirikn Exp $
+ * $DragonFly: src/games/backgammon/common_source/fancy.c,v 1.4 2006/08/08 16:36:11 pavalos Exp $
  */
 
-#include <stdlib.h>
 #include <string.h>
 #include <termcap.h>
 #include "back.h"
 
+static void    bsect(int, int, int, int);
+static void    fixpos(int, int, int, int, int);
+static void    fixcol(int, int, int, int, int);
+static void    newline(void);
+
 char   PC;                     /* padding character */
 char   *BC;                    /* backspace sequence */
 char   *CD;                    /* clear to end of screen sequence */
@@ -81,9 +85,9 @@ int   oldw;
 int    realr;
 int    realc;
 
-int    addbuf (int);
-
-fboard ()  {
+void
+fboard(void)
+{
        int     i, j, l;
 
        curmove (0,0);                          /* do top line */
@@ -180,7 +184,7 @@ fboard ()  {
        oldr = (off[1] < 0? off[1]+15: off[1]);
        oldw = -(off[0] < 0? off[0]+15: off[0]);
 }
-\f
+
 /*
  * bsect (b,rpos,cpos,cnext)
  *     Print the contents of a board position.  "b" has the value of the
@@ -191,12 +195,8 @@ fboard ()  {
  * differently.
  */
 
-bsect (b,rpos,cpos,cnext)
-int    b;                                      /* contents of position */
-int    rpos;                                   /* row of position */
-int    cpos;                                   /* column of position */
-int    cnext;                                  /* direction of position */
-
+static void
+bsect(int b, int rpos, int cpos, int cnext)
 {
        int             j;                      /* index */
        int             n;                      /* number of men on position */
@@ -204,6 +204,7 @@ int cnext;                                  /* direction of position */
        int             k;                      /* index */
        char            pc;                     /* color of men on position */
 
+       bct = 0;
        n = abs(b);                             /* initialize n and pc */
        pc = (b > 0? 'r': 'w');
 
@@ -250,8 +251,10 @@ int        cnext;                                  /* direction of position */
                }
        }
 }
-\f
-refresh()  {
+
+void
+refresh(void)
+{
        int     i, r, c;
 
        r = curr;                               /* save current position */
@@ -307,19 +310,19 @@ refresh()  {
        newpos();
        buflush();
 }
-\f
-fixpos (old,new,r,c,inc)
-int    old, new, r, c, inc;
 
+static void
+fixpos(int cur, int new, int r, int c, int inc)
 {
        int             o, n, nv;
        int             ov, nc;
        char            col;
 
-       if (old*new >= 0)  {
-               ov = abs(old);
+       nc = 0;
+       if (cur*new >= 0)  {
+               ov = abs(cur);
                nv = abs(new);
-               col = (old+new > 0? 'r': 'w');
+               col = (cur+new > 0? 'r': 'w');
                o = (ov-1)/5;
                n = (nv-1)/5;
                if (o == n)  {
@@ -373,14 +376,13 @@ int       old, new, r, c, inc;
        }
        nv = abs(new);
        fixcol (r,c+1,nv,new > 0? 'r': 'w',inc);
-       if (abs(old) <= abs(new))
+       if (abs(cur) <= abs(new))
                return;
-       fixcol (r+inc*new,c+1,abs(old+new),' ',inc);
+       fixcol (r+inc*new,c+1,abs(cur+new),' ',inc);
 }
 
-fixcol (r,c,l,ch,inc)
-int            l, ch, r, c, inc;
-
+static void
+fixcol(int r, int c, int l, int ch, int inc)
 {
        int     i;
 
@@ -391,10 +393,9 @@ int                l, ch, r, c, inc;
                fancyc (ch);
        }
 }
-\f
-curmove (r,c)
-int    r, c;
 
+void
+curmove(int r, int c)
 {
        if (curr == r && curc == c)
                return;
@@ -406,18 +407,19 @@ int       r, c;
        curc = c;
 }
 
-newpos ()  {
+void
+newpos(void)
+{
        int     r;              /* destination row */
        int     c;              /* destination column */
        int     mode = -1;      /* mode of movement */
 
-       int     count = 1000;           /* character count */
+       int     ccount = 1000;          /* character count */
        int     i;                      /* index */
-       int     j;                      /* index */
        int     n;                      /* temporary variable */
        char    *m;                     /* string containing CM movement */
 
-
+       m = NULL;
        if (realr == -1)                /* see if already there */
                return;
 
@@ -435,55 +437,55 @@ newpos ()  {
        if (CM)  {                      /* try CM to get there */
                mode = 0;
                m = (char *)tgoto (CM,c,r);
-               count = strlen (m);
+               ccount = strlen (m);
        }
 
                                        /* try HO and local movement */
-       if (HO && (n = r+c*lND+lHO) < count)  {
+       if (HO && (n = r+c*lND+lHO) < ccount)  {
                mode = 1;
-               count = n;
+               ccount = n;
        }
 
                                        /* try various LF combinations */
        if (r >= curr)  {
                                                /* CR, LF, and ND */
-               if ((n = (r-curr)+c*lND+1) < count)  {
+               if ((n = (r-curr)+c*lND+1) < ccount)  {
                        mode = 2;
-                       count = n;
+                       ccount = n;
                }
                                                /* LF, ND */
-               if (c >= curc && (n = (r-curr)+(c-curc)*lND) < count)  {
+               if (c >= curc && (n = (r-curr)+(c-curc)*lND) < ccount)  {
                        mode = 3;
-                       count = n;
+                       ccount = n;
                }
                                                /* LF, BS */
-               if (c < curc && (n = (r-curr)+(curc-c)*lBC) < count)  {
+               if (c < curc && (n = (r-curr)+(curc-c)*lBC) < ccount)  {
                        mode = 4;
-                       count = n;
+                       ccount = n;
                }
        }
 
                                        /* try corresponding UP combinations */
        if (r < curr)  {
                                                /* CR, UP, and ND */
-               if ((n = (curr-r)*lUP+c*lND+1) < count)  {
+               if ((n = (curr-r)*lUP+c*lND+1) < ccount)  {
                        mode = 5;
-                       count = n;
+                       ccount = n;
                }
                                                /* UP and ND */
-               if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < count)  {
+               if (c >= curc && (n = (curr-r)*lUP+(c-curc)*lND) < ccount)  {
                        mode = 6;
-                       count = n;
+                       ccount = n;
                }
                                                /* UP and BS */
-               if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < count)  {
+               if (c < curc && (n = (curr-r)*lUP+(curc-c)*lBC) < ccount)  {
                        mode = 7;
-                       count = n;
+                       ccount = n;
                }
        }
 
                                                /* space over */
-       if (curr == r && c > curc && linect[r] < curc && c-curc < count)
+       if (curr == r && c > curc && linect[r] < curc && c-curc < ccount)
                mode = 8;
 
        switch (mode)  {
@@ -572,8 +574,10 @@ newpos ()  {
        realr = -1;
        realc = -1;
 }
-\f
-clear ()  {
+
+void
+clear(void)
+{
        int     i;
 
                                        /* double space if can't clear */
@@ -590,9 +594,10 @@ clear ()  {
        tputs (CL,CO,addbuf);           /* put CL in buffer */
 }
 
-\f
-fancyc (c)
-char   c;                      /* character to output */
+
+/* input is character to output */
+void
+fancyc(char c)
 {
        int     sp;             /* counts spaces in a tab */
 
@@ -646,11 +651,11 @@ char      c;                      /* character to output */
                                        /* use cursor movement routine */
                curmove (curr,curc+1);
 }
-\f
-clend()  {
-       int     i;
-       char    *s;
 
+void
+clend(void)
+{
+       int     i;
 
        if (CD)  {
                tputs (CD,CO-curr,addbuf);
@@ -669,10 +674,10 @@ clend()  {
        curmove (i,0);
 }
 
-cline ()  {
-       int     i;
+void
+cline(void)
+{
        int     c;
-       char    *s;
 
        if (curc > linect[curr])
                return;
@@ -691,25 +696,25 @@ cline ()  {
        }
 }
 
-newline ()  {
+static void
+newline(void)
+{
        cline();
        if (curr == LI-1)
                curmove (begscr,0);
        else
                curmove (curr+1,0);
 }
-\f
-int
-getcaps (s)
-const char     *s;
 
+int
+getcaps(const char *s)
 {
        char    *code;          /* two letter code */
        char    ***cap;         /* pointer to cap string */
        char            *bufp;          /* pointer to cap buffer */
        char            tentry[1024];   /* temporary uncoded caps buffer */
 
-       tgetent (tentry, (char *)s);            /* get uncoded termcap entry */
+       tgetent (tentry, s);            /* get uncoded termcap entry */
 
        LI = tgetnum ("li");            /* get number of lines */
        if (LI == -1)
index 256b69d..2d08141 100644 (file)
  *
  * @(#)odds.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/odds.c,v 1.5 1999/11/30 03:48:26 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/odds.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/odds.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 
-odds (r1,r2,val)
-int    r1;
-int            r2, val;
+void
+odds(int r1, int r2, int val)
 {
        int     i, j;
 
@@ -62,7 +61,9 @@ int           r2, val;
        }
 }
 
-count ()  {
+int
+count(void)
+{
        int     i;
        int     j;
        int     total;
@@ -73,13 +74,12 @@ count ()  {
                        total += table[i][j];
        return (total);
 }
-\f
-canhit (i,c)
-int    i, c;
 
+int
+canhit(int i, int c)
 {
        int     j, k, b;
-       int             a, d, diff, place, addon, menstuck;
+       int     a, diff, place, addon, menstuck;
 
        if (c == 0)
                odds (0,0,0);
index eb0cdd3..78a6ea2 100644 (file)
  *
  * @(#)one.c   8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/one.c,v 1.5 1999/11/30 03:48:27 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/one.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/one.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 
-makmove (i)
-int    i;
+static int     checkd(int);
+static int     last(void);
 
+int
+makmove(int i)
 {
        int     n, d;
        int             max;
@@ -90,10 +92,9 @@ int  i;
        }
        return (0);
 }
-\f
-moverr (i)
-int    i;
 
+void
+moverr(int i)
 {
        int     j;
 
@@ -113,27 +114,27 @@ int       i;
        movback (i);
 }
 
-
-checkd (d)
-int    d;
-
+static int
+checkd(int d)
 {
        if (d0 != d)
                swap;
        return (0);
 }
 
-last ()  {
+static int
+last(void)
+{
        int     i;
 
        for (i = home-6*cturn; i != home; i += cturn)
                if (board[i]*cturn > 0)
                        return (abs(home-i));
+       return(-1);
 }
-\f
-movback (i)
-int    i;
 
+void
+movback(int i)
 {
        int     j;
 
@@ -141,9 +142,8 @@ int i;
                backone(j);
 }
 
-backone (i)
-int    i;
-
+void
+backone(int i)
 {
        board[p[i]] += cturn;
        if (g[i] != home)  {
index ad87af1..3674548 100644 (file)
  *
  * @(#)save.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/save.c,v 1.8 1999/11/30 03:48:27 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/save.c,v 1.3 2006/03/22 20:06:13 drhodus Exp $
+ * $DragonFly: src/games/backgammon/common_source/save.c,v 1.4 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <fcntl.h>
 #include <errno.h>
 #include "back.h"
 
+static void    norec(const char *);
+
 static const char      confirm[] = "Are you sure you want to leave now?";
 static const char      prompt[] = "Enter a file name:  ";
 static const char      exist1[] = "The file '";
@@ -50,9 +52,8 @@ static const char     type[] = "'.\nType \"backgammon ";
 static const char      rec[] = "\" to recover your game.\n\n";
 static const char      cantrec[] = "Can't recover file:  ";
 
-save (n)
-int    n;
-
+void
+save(int n)
 {
        int     fdesc;
        char    *fs;
@@ -139,13 +140,10 @@ int       n;
                clend();
        getout ();
 }
-\f
-int
-recover (s)
-const char     *s;
 
+void
+recover(const char *s)
 {
-       int     i;
        int             fdesc;
 
        if ((fdesc = open (s,O_RDONLY)) == -1)
@@ -165,10 +163,8 @@ const char *s;
        rflag = 1;
 }
 
-int
-norec (s)
-const char     *s;
-
+static void
+norec(const char *s)
 {
        const char      *c;
 
index 777a76e..5906aa9 100644 (file)
  *
  * @(#)subs.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/subs.c,v 1.12 1999/11/30 03:48:27 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/subs.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/common_source/subs.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 #include "back.h"
 
@@ -60,17 +59,16 @@ const char  *const descr[] = {
        0
 };
 
-errexit (s)
-char   *s;
+void
+errexit(const char *s)
 {
        write (2,"\n",1);
        perror (s);
        getout();
 }
 
-int addbuf (c)
-int    c;
-
+int
+addbuf(int c)
 {
        buffnum++;
        if (buffnum == BUFSIZ)  {
@@ -82,7 +80,9 @@ int   c;
        return (0);
 }
 
-buflush ()  {
+void
+buflush(void)
+{
        if (buffnum < 0)
                return;
        buffnum++;
@@ -91,7 +91,9 @@ buflush ()  {
        buffnum = -1;
 }
 
-readc () {
+char
+readc(void)
+{
        char    c;
 
        if (tflag)  {
@@ -116,8 +118,8 @@ readc () {
        return (c);
 }
 
-writec (c)
-char   c;
+void
+writec(char c)
 {
        if (tflag)
                fancyc (c);
@@ -126,8 +128,7 @@ char        c;
 }
 
 void
-writel (l)
-const char     *l;
+writel(const char *l)
 {
 #ifdef DEBUG
        const char      *s;
@@ -150,7 +151,9 @@ const char  *l;
                writec (*l++);
 }
 
-proll ()   {
+void
+proll(void)
+{
        if (d0)
                swap;
        if (cturn == 1)
@@ -164,8 +167,8 @@ proll ()   {
                cline();
 }
 
-wrint (n)
-int    n;
+void
+wrint(int n)
 {
        int     i, j, t;
 
@@ -179,12 +182,15 @@ int       n;
        writec (n%10+'0');
 }
 
-gwrite()  {
+void
+gwrite(void)
+{
        int     r, c;
 
+       r = curr;
+       c = curc;
+
        if (tflag)  {
-               r = curr;
-               c = curc;
                curmove (16,0);
        }
 
@@ -221,9 +227,9 @@ gwrite()  {
        }
 }
 
-quit ()  {
-       int     i;
-
+int
+quit(void)
+{
        if (tflag)  {
                curmove (20,0);
                clend();
@@ -242,8 +248,8 @@ quit ()  {
        return (0);
 }
 
-yorn (special)
-char   special;                        /* special response */
+int
+yorn(char special)
 {
        char    c;
        int     i;
@@ -272,8 +278,8 @@ char        special;                        /* special response */
        return (c == 'Y');
 }
 
-wrhit (i)
-int    i;
+void
+wrhit(int i)
 {
        writel ("Blot hit on ");
        wrint (i);
@@ -281,7 +287,9 @@ int i;
        writec ('\n');
 }
 
-nexturn ()  {
+void
+nexturn(void)
+{
        int     c;
 
        cturn = -cturn;
@@ -296,14 +304,10 @@ nexturn ()  {
        colorptr += c;
 }
 
-getarg (argc, argv)
-int    argc;
-char   **argv;
-
+void
+getarg(int argc, char **argv)
 {
        char    ch;
-       extern int optind;
-       extern char *optarg;
        int i;
 
        /* process arguments here.  dashes are ignored, nbrw are ignored
@@ -381,7 +385,9 @@ char        **argv;
                recover(argv[0]);
 }
 
-init ()  {
+void
+init(void)
+{
        int     i;
        for (i = 0; i < 26;)
                board[i++] = 0;
@@ -397,7 +403,9 @@ init ()  {
        dlast = 0;
 }
 
-wrscore ()  {
+void
+wrscore(void)
+{
        writel ("Score:  ");
        writel (color[1]);
        writec (' ');
@@ -408,19 +416,20 @@ wrscore ()  {
        wrint (wscore);
 }
 
-fixtty (mode)
-int    mode;
+void
+fixtty(int mode)
 {
        if (tflag)
                newpos();
        buflush();
        tty.sg_flags = mode;
-       if (stty (0,&tty) < 0)
+       if (ioctl(0, TIOCSETP, &tty) < 0)
                errexit("fixtty");
 }
 
 void
-getout ()  {
+getout(void)
+{
        /* go to bottom of screen */
        if (tflag)  {
                curmove (23,0);
@@ -432,15 +441,18 @@ getout ()  {
        fixtty (old);
        exit(0);
 }
-roll ()  {
+
+void
+roll(void)
+{
        char    c;
        int     row;
        int     col;
 
        if (iroll)  {
+               row = curr;
+               col = curc;
                if (tflag)  {
-                       row = curr;
-                       col = curc;
                        curmove (17,0);
                } else
                        writec ('\n');
index 5217d41..dce7806 100644 (file)
  *
  * @(#)table.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/common_source/table.c,v 1.5 1999/11/30 03:48:28 billf Exp $
- * $DragonFly: src/games/backgammon/common_source/table.c,v 1.3 2006/03/22 20:06:34 drhodus Exp $
+ * $DragonFly: src/games/backgammon/common_source/table.c,v 1.4 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 
+static int     dotable(char, int);
+static int     rsetbrd(void);
+
 const char     *const help2[] = {
        "   Enter moves as <s>-<f> or <s>/<r> where <s> is the starting",
        "position, <f> is the finishing position, and <r> is the roll.",
@@ -52,36 +55,33 @@ struct state        {
 
 static const struct state      atmata[] = {
 
-       'R', 1, 0,      '?', 7, 0,      'Q', 0, -3,     'B', 8, 25,
-       '9', 2, 25,     '8', 2, 25,     '7', 2, 25,     '6', 2, 25,
-       '5', 2, 25,     '4', 2, 25,     '3', 2, 25,     '2', 2, 19,
-       '1', 2, 15,     '0', 2, 25,     '.', 0, 0,      '9', 2, 25,
-       '8', 2, 25,     '7', 2, 25,     '6', 2, 25,     '5', 2, 25,
-
-       '4', 2, 25,     '3', 2, 25,     '2', 2, 25,     '1', 2, 25,
-       '0', 2, 25,     '/', 0, 32,     '-', 0, 39,     '.', 0, 0,
-       '/', 5, 32,     ' ', 6, 3,      ',', 6, 3,      '\n', 0, -1,
-       '6', 3, 28,     '5', 3, 28,     '4', 3, 28,     '3', 3, 28,
-       '2', 3, 28,     '1', 3, 28,     '.', 0, 0,      'H', 9, 61,
-
-       '9', 4, 61,     '8', 4, 61,     '7', 4, 61,     '6', 4, 61,
-       '5', 4, 61,     '4', 4, 61,     '3', 4, 61,     '2', 4, 53,
-       '1', 4, 51,     '0', 4, 61,     '.', 0, 0,      '9', 4, 61,
-       '8', 4, 61,     '7', 4, 61,     '6', 4, 61,     '5', 4, 61,
-       '4', 4, 61,     '3', 4, 61,     '2', 4, 61,     '1', 4, 61,
-
-       '0', 4, 61,     ' ', 6, 3,      ',', 6, 3,      '-', 5, 39,
-       '\n', 0, -1,    '.', 0, 0
+       {'R', 1, 0},    {'?', 7, 0},    {'Q', 0, -3},   {'B', 8, 25},
+       {'9', 2, 25},   {'8', 2, 25},   {'7', 2, 25},   {'6', 2, 25},
+       {'5', 2, 25},   {'4', 2, 25},   {'3', 2, 25},   {'2', 2, 19},
+       {'1', 2, 15},   {'0', 2, 25},   {'.', 0, 0},    {'9', 2, 25},
+       {'8', 2, 25},   {'7', 2, 25},   {'6', 2, 25},   {'5', 2, 25},
+
+       {'4', 2, 25},   {'3', 2, 25},   {'2', 2, 25},   {'1', 2, 25},
+       {'0', 2, 25},   {'/', 0, 32},   {'-', 0, 39},   {'.', 0, 0},
+       {'/', 5, 32},   {' ', 6, 3},    {',', 6, 3},    {'\n', 0, -1},
+       {'6', 3, 28},   {'5', 3, 28},   {'4', 3, 28},   {'3', 3, 28},
+       {'2', 3, 28},   {'1', 3, 28},   {'.', 0, 0},    {'H', 9, 61},
+
+       {'9', 4, 61},   {'8', 4, 61},   {'7', 4, 61},   {'6', 4, 61},
+       {'5', 4, 61},   {'4', 4, 61},   {'3', 4, 61},   {'2', 4, 53},
+       {'1', 4, 51},   {'0', 4, 61},   {'.', 0, 0},    {'9', 4, 61},
+       {'8', 4, 61},   {'7', 4, 61},   {'6', 4, 61},   {'5', 4, 61},
+       {'4', 4, 61},   {'3', 4, 61},   {'2', 4, 61},   {'1', 4, 61},
+
+       {'0', 4, 61},   {' ', 6, 3},    {',', 6, 3},    {'-', 5, 39},
+       {'\n', 0, -1},  {'.', 0, 0}
 };
 
-checkmove (ist)
-
-int    ist;
-
+int
+checkmove(int ist)
 {
        int     j, n;
        char    c;
-       char            a;
 
 domove:
        if (ist == 0)  {
@@ -197,13 +197,11 @@ dochar:
        writec ('\007');
        goto dochar;
 }
-\f
-dotable (c,i)
-char           c;
-int    i;
 
+static int
+dotable(char c, int i)
 {
-       int     a, j;
+       int     a;
        int             test;
 
        test = (c == 'R');
@@ -294,8 +292,10 @@ int        i;
 
        return (-5);
 }
-\f
-rsetbrd ()  {
+
+static int
+rsetbrd(void)
+{
        int     i, j, n;
 
        n = 0;
index 56ceb88..28c5830 100644 (file)
@@ -1,13 +1,15 @@
 #      @(#)Makefile    8.1 (Berkeley) 5/31/93
+# $DragonFly: src/games/backgammon/teachgammon/Makefile,v 1.2 2006/08/08 16:36:11 pavalos Exp $
 
 PROG=  teachgammon
-CFLAGS+=-DV7 -I${.CURDIR}/../common_source
+CFLAGS+=-DTEACHGAMMON_TEXT -DV7 -I${.CURDIR}/../common_source
 SRCS=  allow.c board.c check.c data.c fancy.c init.c odds.c one.c save.c \
        subs.c table.c teach.c ttext1.c ttext2.c tutor.c
-DPADD= ${LIBTERMCAP} ${LIBCOMPAT}
-LDADD= -ltermcap -lcompat
+DPADD= ${LIBTERMCAP}
+LDADD= -ltermcap
 HIDEGAME=hidegame
 NOMAN= noman
+WARNS?=        6
 
 .PATH: ${.CURDIR}/../common_source
 
index 37d348f..4ff61af 100644 (file)
@@ -32,7 +32,7 @@
  *
  * @(#)data.c  8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/teachgammon/data.c,v 1.4 1999/11/30 03:48:29 billf Exp $
- * $DragonFly: src/games/backgammon/teachgammon/data.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/teachgammon/data.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "tutor.h"
@@ -218,98 +218,98 @@ const char  *const text23[] = {
 const struct situatn  test[] = {
        {
                {0,2,0,0,0,0,-5,0,-3,0,0,0,5,-5,0,0,0,3,0,5,0,0,0,0,-2,0},
-               3, 1, {8,6,0,0}, {5,5,0,0}, 4, 2, text0
+               3, 1, {8,6,0,0}, {5,5,0,0}, 4, 2, {text0}
        },
        {
                {0,2,0,0,0,-2,-4,0,-2,0,0,0,5,-5,0,0,0,2,0,4,0,2,0,0,-2,0},
-               5, 5, {13,13,8,8}, {8,8,3,3}, 6, 6, text1
+               5, 5, {13,13,8,8}, {8,8,3,3}, 6, 6, {text1}
        },
        {
                {0,0,0,-2,0,-2,-4,2,-2,0,0,0,3,-3,0,0,0,2,2,4,0,2,0,0,-2,0},
-               6, 5, {13,8,0,0}, {8,2,0,0}, 1, 2, text2
+               6, 5, {13,8,0,0}, {8,2,0,0}, 1, 2, {text2}
        },
        {
                {0,0,-1,-2,0,-2,-4,2,-2,0,0,0,2,-2,0,1,0,2,2,4,0,2,0,0,-2,0},
-               4, 5, {24,20,0,0}, {20,15,0,0}, 2, 5, text3
+               4, 5, {24,20,0,0}, {20,15,0,0}, 2, 5, {text3}
        },
        {
                {0,0,0,-2,0,-2,-4,3,-2,0,0,0,2,-2,0,-1,0,2,2,4,0,2,0,0,-1,-1},
-               2, 3, {25,24,0,0}, {22,22,0,0}, 4, 1, text4
+               2, 3, {25,24,0,0}, {22,22,0,0}, 4, 1, {text4}
        },
        {
                {0,0,0,-2,0,-2,-4,2,-2,0,0,0,3,-2,0,-1,0,2,2,4,0,2,-2,0,0,0},
-               6, 1, {22,16,0,0}, {16,15,0,0}, 3, 3, text5
+               6, 1, {22,16,0,0}, {16,15,0,0}, 3, 3, {text5}
        },
        {
                {0,0,0,-2,0,-2,-4,2,-2,0,0,0,3,-2,0,-2,0,0,2,2,2,2,2,0,0,-1},
-               3, 5, {0,0,0,0}, {0,0,0,0}, 5, 4, text6
+               3, 5, {0,0,0,0}, {0,0,0,0}, 5, 4, {text6}
        },
        {
                {0,0,0,-2,0,-2,-4,1,-2,0,0,0,3,-2,0,-2,1,0,2,2,2,2,2,0,0,-1},
-               6, 6, {0,0,0,0}, {0,0,0,0}, 3, 6, text7
+               6, 6, {0,0,0,0}, {0,0,0,0}, 3, 6, {text7}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-2,0,0,0,3,-2,0,-2,2,0,2,2,2,2,2,0,0,-1},
-               2, 6, {25,23,0,0}, {23,17,0,0}, 5, 1, text8
+               2, 6, {25,23,0,0}, {23,17,0,0}, 5, 1, {text8}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-2,0,0,0,2,-2,0,-2,2,0,3,2,2,2,2,0,0,-1},
-               1, 1, {25,24,15,15}, {24,23,14,14}, 4, 6, text9
+               1, 1, {25,24,15,15}, {24,23,14,14}, 4, 6, {text9}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-2,0,0,0,0,-2,-2,0,3,0,4,2,2,2,2,-1,0,0},
-               6, 2, {23,17,0,0}, {17,15,0,0}, 1, 3, text10
+               6, 2, {23,17,0,0}, {17,15,0,0}, 1, 3, {text10}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-2,0,0,0,0,-2,-2,-1,2,0,3,4,2,2,2,0,0,0},
-               4, 3, {15,14,0,0}, {11,11,0,0}, 5, 3, text11
+               4, 3, {15,14,0,0}, {11,11,0,0}, 5, 3, {text11}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-2,0,0,-2,0,-2,-1,0,0,0,3,5,2,3,2,0,0,0},
-               6, 1, {14,13,0,0}, {8,12,0,0}, 4, 4, text12
+               6, 1, {14,13,0,0}, {8,12,0,0}, 4, 4, {text12}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-3,0,0,-2,-1,-1,0,0,0,0,0,5,2,2,5,0,0,0},
-               2, 1, {13,12,0,0}, {11,11,0,0}, 2, 1, text13
+               2, 1, {13,12,0,0}, {11,11,0,0}, 2, 1, {text13}
        },
        {
                {0,0,0,-2,0,-2,-4,0,-3,0,0,-4,0,0,0,0,0,0,0,5,2,2,3,1,1,0},
-               2, 5, {8,11,0,0}, {6,6,0,0}, 6, 3, text14
+               2, 5, {8,11,0,0}, {6,6,0,0}, 6, 3, {text14}
        },
        {
                {0,0,0,-2,0,-2,-6,0,-2,0,0,-3,0,0,0,0,0,0,0,4,2,2,2,1,1,0},
-               4, 3, {11,11,0,0}, {7,8,0,0}, 2, 5, text15
+               4, 3, {11,11,0,0}, {7,8,0,0}, 2, 5, {text15}
        },
        {
                {0,0,0,-2,0,-2,-6,-1,-3,0,0,-1,0,0,0,0,0,0,0,4,1,2,2,0,1,0},
-               2, 6, {8,11,0,0}, {6,5,0,0}, 6, 1, text16
+               2, 6, {8,11,0,0}, {6,5,0,0}, 6, 1, {text16}
        },
        {
                {0,0,0,-2,0,-3,-7,-1,-2,0,0,0,0,0,0,0,0,0,0,3,1,2,2,0,0,0},
-               5, 3, {8,7,0,0}, {3,4,0,0}, 5, 2, text17
+               5, 3, {8,7,0,0}, {3,4,0,0}, 5, 2, {text17}
        },
        {
                {0,0,0,-3,-1,-3,-7,0,-1,0,0,0,0,0,0,0,0,0,0,3,0,1,2,1,0,0},
-               3, 3, {8,3,3,3}, {5,0,0,0}, 1, 6, text18
+               3, 3, {8,3,3,3}, {5,0,0,0}, 1, 6, {text18}
        },
        {
                {0,0,0,0,-1,-4,-7,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,2,1,0,0},
-               1, 4, {4,5,0,0}, {0,4,0,0}, 2, 3, text19
+               1, 4, {4,5,0,0}, {0,4,0,0}, 2, 3, {text19}
        },
        {
                {0,0,0,0,-1,-3,-7,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,0},
-               5, 6, {6,5,0,0}, {0,0,0,0}, 1, 4, text20
+               5, 6, {6,5,0,0}, {0,0,0,0}, 1, 4, {text20}
        },
        {
                {0,0,0,0,-1,-2,-6,0,0,0,0,0,0,0,0,0,0,0,0,1,0,1,1,0,0,0},
-               2, 4, {4,6,0,0}, {0,4,0,0}, 6, 2, text21
+               2, 4, {4,6,0,0}, {0,4,0,0}, 6, 2, {text21}
        },
        {
                {0,0,0,0,-1,-2,-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,0,0},
-               3, 1, {4,3,0,0}, {3,0,0,0}, 4, 3, text22
+               3, 1, {4,3,0,0}, {3,0,0,0}, 4, 3, {text22}
        },
        {
                {0,0,0,0,0,-2,-5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
-               0, 0, {0,0,0,0}, {0,0,0,0}, 0, 0, text23
+               0, 0, {0,0,0,0}, {0,0,0,0}, 0, 0, {text23}
        }
 };
index 53544f2..1b2acba 100644 (file)
  * @(#) Copyright (c) 1980, 1993 The Regents of the University of California.  All rights reserved.
  * @(#)teach.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/teachgammon/teach.c,v 1.12 1999/11/30 03:48:30 billf Exp $
- * $DragonFly: src/games/backgammon/teachgammon/teach.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/teachgammon/teach.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include <string.h>
 #include <sys/types.h>
-#include <unistd.h>
 #include <signal.h>
 #include "back.h"
-
-extern char    *hello[];
-extern char    *list[];
-extern char    *intro1[];
-extern char    *intro2[];
-extern char    *moves[];
-extern char    *remove[];
-extern char    *hits[];
-extern char    *endgame[];
-extern char    *doubl[];
-extern char    *stragy[];
-extern char    *prog[];
-extern char    *lastch[];
-
-extern char    ospeed;                 /* tty output speed for termlib */
+#include "tutor.h"
 
 const char *const helpm[] = {
        "\nEnter a space or newline to roll, or",
@@ -70,10 +55,8 @@ const char *const contin[] = {
        0
 };
 
-main (argc,argv)
-int    argc;
-char   **argv;
-
+int
+main(int argc, char **argv)
 {
        int     i;
 
@@ -81,8 +64,8 @@ char  **argv;
        setgid(getgid());
 
        acnt = 1;
-       signal (SIGINT,getout);
-       if (gtty (0,&tty) == -1)                        /* get old tty mode */
+       signal (SIGINT,(sig_t)getout);
+       if (ioctl(0,TIOCGETP,&tty) == -1)                       /* get old tty mode */
                errexit ("teachgammon(gtty)");
        old = tty.sg_flags;
 #ifdef V7
@@ -90,7 +73,6 @@ char  **argv;
 #else
        raw = ((noech = old & ~ECHO) | RAW);            /* set up modes */
 #endif
-       ospeed = tty.sg_ospeed;                         /* for termlib */
        tflag = getcaps (getenv ("TERM"));
        getarg (argc, argv);
        if (tflag)  {
@@ -111,48 +93,52 @@ char       **argv;
                        leave();
 
                case 2:
-                       if (i = text(intro1))
+                       if ((i = text(intro1)) != 0)
                                break;
                        wrboard();
-                       if (i = text(intro2))
+                       if ((i = text(intro2)) != 0)
                                break;
 
                case 3:
-                       if (i = text(moves))
+                       if ((i = text(moves)) != 0)
                                break;
 
                case 4:
-                       if (i = text(remove))
+                       if ((i = text(remove)) != 0)
                                break;
 
                case 5:
-                       if (i = text(hits))
+                       if ((i = text(hits)) != 0)
                                break;
 
                case 6:
-                       if (i = text(endgame))
+                       if ((i = text(endgame)) != 0)
                                break;
 
                case 7:
-                       if (i = text(doubl))
+                       if ((i = text(doubl)) != 0)
                                break;
 
                case 8:
-                       if (i = text(stragy))
+                       if ((i = text(stragy)) != 0)
                                break;
 
                case 9:
-                       if (i = text(prog))
+                       if ((i = text(prog)) != 0)
                                break;
 
                case 10:
-                       if (i = text(lastch))
+                       if ((i = text(lastch)) != 0)
                                break;
                }
        tutor();
+       /* NOTREACHED */
+       return(0);
 }
 
-leave()  {
+void
+leave(void)
+{
        int i;
        if (tflag)
                clear();
index 12c0f5c..85f9e94 100644 (file)
@@ -32,7 +32,7 @@
  *
  * @(#)ttext1.c        8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/teachgammon/ttext1.c,v 1.3 1999/11/30 03:48:30 billf Exp $
- * $DragonFly: src/games/backgammon/teachgammon/ttext1.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/teachgammon/ttext1.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
@@ -98,7 +98,7 @@ const char    *const intro2[] = {
     "have any pieces of either color.",
     "",
     0};
-\f
+
 const char     *const moves[] = {
     "\nMoves and Points:",
     "\n   Moves are made along the positions on the board according to",
@@ -153,7 +153,7 @@ const char  *const remove[] = {
     "many moves as possible.",
     "",
     0};
-\f
+
 const char     *const hits[] = {
     "\nHitting Blots:",
     "\n   Although two men on a position form an impenetrable point, a",
@@ -170,7 +170,7 @@ const char  *const hits[] = {
     "bar, as well as being set back the full distance of the board.",
     "",
     0};
-\f
+
 const char     *const endgame[] = {
     "\nEnding the Game and Scoring:",
     "\n   Winning a game usually wins one point, the normal value of a",
index 5d45669..6a456d5 100644 (file)
@@ -32,7 +32,7 @@
  *
  * @(#)ttext2.c        8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/teachgammon/ttext2.c,v 1.3.2.1 2001/10/15 13:46:32 dd Exp $
- * $DragonFly: src/games/backgammon/teachgammon/ttext2.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/teachgammon/ttext2.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
@@ -70,7 +70,7 @@ const char    *const stragy[] = {
     "tional hints on strategy are presented in the practice game.",
     "",
     0};
-\f
+
 const char     *const prog[] = {
    "\nThe Program and How It Works:",
    "\n   A general rule of thumb is when you don't know what to do,",
@@ -123,11 +123,9 @@ const char *const lastch[] = {
    "torial starts.",
    "",
    0};
-\f
-int
-text (txt)
-const char     *const *txt;
 
+int
+text(const char *const *txt)
 {
        const char      *const *begin;
        const char      *a;
index b34dbf2..f45155d 100644 (file)
  *
  * @(#)tutor.c 8.1 (Berkeley) 5/31/93
  * $FreeBSD: src/games/backgammon/teachgammon/tutor.c,v 1.5 1999/11/30 03:48:31 billf Exp $
- * $DragonFly: src/games/backgammon/teachgammon/tutor.c,v 1.2 2003/06/17 04:25:22 dillon Exp $
+ * $DragonFly: src/games/backgammon/teachgammon/tutor.c,v 1.3 2006/08/08 16:36:11 pavalos Exp $
  */
 
 #include "back.h"
 #include "tutor.h"
 
-extern int     maxmoves;
-extern const char      *const finis[];
-
-extern const struct situatn    test[];
+static void    clrest(void);
+static int     brdeq(const int *, const int *);
 
 static const char      better[] = "That is a legal move, but there is a better one.\n";
 
 void
-tutor ()  {
+tutor(void)
+{
        int     i, j;
 
        i = 0;
@@ -130,7 +129,9 @@ tutor ()  {
        leave();
 }
 
-clrest ()  {
+static void
+clrest(void)
+{
        int     r, c, j;
 
        r = curr;
@@ -142,10 +143,8 @@ clrest ()  {
        curmove (r,c);
 }
 
-int
-brdeq (b1,b2)
-const int  *b1, *b2;
-
+static int
+brdeq(const int *b1, const int *b2)
 {
        const int  *e;
 
index 8b20e33..6cacdd5 100644 (file)
  * SUCH DAMAGE.
  *
  *     @(#)tutor.h     8.1 (Berkeley) 5/31/93
+ * $DragonFly: src/games/backgammon/teachgammon/tutor.h,v 1.2 2006/08/08 16:36:11 pavalos Exp $
  */
 
+void   leave(void);
+void   tutor(void);
+
 struct situatn  {
        int     brd[26];
        int     roll1;
@@ -58,6 +62,7 @@ extern        const char      *const moves[];
 extern const char      *const opts;
 extern const char      *const prog[];
 extern const char      *const prompt;
+extern const char      *const remove[];
 extern const char      *const removepiece[];
 extern const char      *const stragy[];
 extern const struct situatn    test[];