Return to save.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / backgammon

Annotation of 42BSD/games/backgammon/save.c, revision 1.1.1.1

1.1       root        1: static char    sccsid[] = "    save.c  4.2     82/11/27        ";
                      2: 
                      3: #include "back.h"
                      4: 
                      5: extern int     errno;
                      6: 
                      7: static char    confirm[] = "Are you sure you want to leave now?";
                      8: static char    prompt[] = "Enter a file name:  ";
                      9: static char    exist1[] = "The file '";
                     10: static char    exist2[] =
                     11:        "' already exists.\nAre you sure you want to use this file?";
                     12: static char    cantuse[] = "\nCan't use ";
                     13: static char    saved[] = "This game has been saved on the file '";
                     14: static char    type[] = "'.\nType \"backgammon ";
                     15: static char    rec[] = "\" to recover your game.\n\n";
                     16: static char    cantrec[] = "Can't recover file:  ";
                     17: 
                     18: save (n)
                     19: register int   n;
                     20: 
                     21: {
                     22:        register int    fdesc;
                     23:        register char   *fs;
                     24:        char            fname[50];
                     25: 
                     26:        if (n)  {
                     27:                if (tflag)  {
                     28:                        curmove (20,0);
                     29:                        clend();
                     30:                } else
                     31:                        writec ('\n');
                     32:                writel (confirm);
                     33:                if (! yorn(0))
                     34:                        return;
                     35:        }
                     36:        cflag = 1;
                     37:        for (;;)  {
                     38:                writel (prompt);
                     39:                fs = fname;
                     40:                while ((*fs = readc()) != '\n')  {
                     41:                        if (*fs == tty.sg_erase)  {
                     42:                                if (fs > fname)  {
                     43:                                        fs--;
                     44:                                        if (tflag)
                     45:                                                curmove (curr,curc-1);
                     46:                                        else
                     47:                                                writec (*fs);
                     48:                                } else
                     49:                                        writec ('\007');
                     50:                                continue;
                     51:                        }
                     52:                        writec (*fs++);
                     53:                }
                     54:                *fs = '\0';
                     55:                if ((fdesc = open(fname,2)) == -1 && errno == 2)  {
                     56:                        if ((fdesc = creat (fname,0700)) != -1)
                     57:                        break;
                     58:                }
                     59:                if (fdesc != -1)  {
                     60:                        if (tflag)  {
                     61:                                curmove (18,0);
                     62:                                clend();
                     63:                        } else
                     64:                                writec ('\n');
                     65:                        writel (exist1);
                     66:                        writel (fname);
                     67:                        writel (exist2);
                     68:                        cflag = 0;
                     69:                        close (fdesc);
                     70:                        if (yorn (0))  {
                     71:                                unlink (fname);
                     72:                                fdesc = creat (fname,0700);
                     73:                                break;
                     74:                        } else  {
                     75:                                cflag = 1;
                     76:                                continue;
                     77:                        }
                     78:                }
                     79:                writel (cantuse);
                     80:                writel (fname);
                     81:                writel (".\n");
                     82:                close (fdesc);
                     83:                cflag = 1;
                     84:        }
                     85:        write (fdesc,board,sizeof board);
                     86:        write (fdesc,off,sizeof off);
                     87:        write (fdesc,in,sizeof in);
                     88:        write (fdesc,dice,sizeof dice);
                     89:        write (fdesc,&cturn,sizeof cturn);
                     90:        write (fdesc,&dlast,sizeof dlast);
                     91:        write (fdesc,&pnum,sizeof pnum);
                     92:        write (fdesc,&rscore,sizeof rscore);
                     93:        write (fdesc,&wscore,sizeof wscore);
                     94:        write (fdesc,&gvalue,sizeof gvalue);
                     95:        write (fdesc,&raflag,sizeof raflag);
                     96:        close (fdesc);
                     97:        if (tflag)
                     98:                curmove (18,0);
                     99:        writel (saved);
                    100:        writel (fname);
                    101:        writel (type);
                    102:        writel (fname);
                    103:        writel (rec);
                    104:        if (tflag)
                    105:                clend();
                    106:        getout ();
                    107: }
                    108: 
                    109: recover (s)
                    110: char   *s;
                    111: 
                    112: {
                    113:        register int    i;
                    114:        int             fdesc;
                    115: 
                    116:        if ((fdesc = open (s,0)) == -1)
                    117:                norec (s);
                    118:        read (fdesc,board,sizeof board);
                    119:        read (fdesc,off,sizeof off);
                    120:        read (fdesc,in,sizeof in);
                    121:        read (fdesc,dice,sizeof dice);
                    122:        read (fdesc,&cturn,sizeof cturn);
                    123:        read (fdesc,&dlast,sizeof dlast);
                    124:        read (fdesc,&pnum,sizeof pnum);
                    125:        read (fdesc,&rscore,sizeof rscore);
                    126:        read (fdesc,&wscore,sizeof wscore);
                    127:        read (fdesc,&gvalue,sizeof gvalue);
                    128:        read (fdesc,&raflag,sizeof raflag);
                    129:        close (fdesc);
                    130:        rflag = 1;
                    131: }
                    132: 
                    133: norec (s)
                    134: register char  *s;
                    135: 
                    136: {
                    137:        register char   *c;
                    138: 
                    139:        tflag = 0;
                    140:        writel (cantrec);
                    141:        c = s;
                    142:        while (*c != '\0')
                    143:                writec (*c++);
                    144:        getout ();
                    145: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.