Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/games/volume16/nethck31/part38

Text File | 1993-01-31 | 57.6 KB | 2,682 lines

Path: uunet!news.tek.com!master!saab!billr
From: [e-mail] (Bill Randle)
Newsgroups: comp.sources.games
Subject: v16i046:  nethack31 - display oriented dungeons & dragons (Ver. 3.1), Part38/108
Message-ID: <[e-mail]>
Date: 30 Jan 93 01:12:17 GMT
Sender: [e-mail]
Lines: 2670
Approved: [e-mail]
Xref: uunet comp.sources.games:1595

Submitted-by: [e-mail] (Izchak Miller)
Posting-number: Volume 16, Issue 46
Archive-name: nethack31/Part38
Supersedes: nethack3p9: Volume 10, Issue 46-102
Environment: Amiga, Atari, Mac, MS-DOS, OS2, Unix, VMS, X11



#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 38 (of 108)."
# Contents:  sys/amiga/wbcli.c sys/msdos/trampoli.c
# Wrapped by billr@saab on Wed Jan 27 16:09:01 1993
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'sys/amiga/wbcli.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'sys/amiga/wbcli.c'\"
else
echo shar: Extracting \"'sys/amiga/wbcli.c'\" \(38406 characters\)
sed "s/^X//" >'sys/amiga/wbcli.c' <<'END_OF_FILE'
X/*    SCCS Id: @(#)wbcli.c  2.1   93/01/08              */
X/*    Copyright (c) Kenneth Lorber, Bethesda, Maryland, 1991      */
X/*    Copyright (c) Gregg Wonderly, Naperville, IL, 1992, 1993    */
X/* NetHack may be freely redistributed.  See license for details. */
X
X/* Friendly Intuition interface for NetHack 3.1 on the Amiga */
X
X/*
X * This file contains many routines common to the CLI and WB interfaces,
X * along with a few specific to each.  #defining CLI supports the CLI
X * interface; not #defining it supports (along with wb.c) the WB interface.
X */
X
X#include "Incl:date.h"          /* this gives us the version string */
X
X#ifdef AZTEC_C
X/* Aztec doesn't recognize __chip syntax */
X# define __chip
X#endif
X
X#include "Amiga:wbdefs.h"       /* Miscellany information */
X#ifdef  INTUI_NEW_LOOK
X#define NewWindow   ExtNewWindow
X#define NewScreen   ExtNewScreen
X#endif
X#include "Amiga:wbstruct.h"
X#include "Amiga:wbprotos.h"
X
X#ifdef CLI
X#include "Amiga:wbdata.c"       /* All structures and global data */
X
X#undef NetHackCnf
Xchar NetHackCnf[50]="NetHack:NetHack.cnf";
X#endif  /* CLI */
X
X#define C_GREY  0
X#define C_BLACK 1
X#define C_WHITE 2
X#define C_BLUE  3
X
X#ifndef __SASC_60
Xextern char *sys_errlist[];
X#endif
Xextern int errno;
X
X#define SPLIT           /* use splitter, if available */
X
Xvoid diskobj_filter(struct DiskObject *);
XBPTR s_LoadSeg(char *);
Xvoid s_UnLoadSeg(void);
X
X#ifdef CLI
Xchar *cnfsavedir="NetHack:save";    /* unless overridden in cnf file */
Xchar argline[255];  /* no overflow - bigger than ADOS will pass */
X
Xvoid WaitEOG(GPTR);
Xchar *eos(char *);
Xvoid condaddslash(char *);
X
X# ifdef SPLIT
Xint running_split=0;        /* if 0, using normal LoadSeg/UnLoadSeg */
X# endif
X#else
Xextern char *options[NUMIDX+1];
Xextern GPTR gamehead,gameavail;
Xextern DEFAULTS defgame;
Xextern struct Window *win;
X#endif  /* CLI */
X
X#ifdef AZTEC_C
Xextern char *strdup(char *);
X
X/*
X * Aztec has a strnicmp, but it doesn't work properly.
X *
X * Note: this came out of NHS:hacklib.c
X */
Xstatic char
Xlowc(c)         /* force 'c' into lowercase */
X    char c;
X{
X    return ('A' <= c && c <= 'Z') ? (c | 040) : c;
X}
X
Xint
Xstrnicmp(s1, s2, n)
X    register const char *s1, *s2;
X    register int n;
X{
X    register char t1, t2;
X
X    while (n--) {
X    if (!*s2) return (*s1 != 0);    /* s1 >= s2 */
X    else if (!*s1) return -1;   /* s1  < s2 */
X    t1 = lowc(*s1++);
X    t2 = lowc(*s2++);
X    if (t1 != t2) return (t1 > t2) ? 1 : -1;
X    }
X    return 0;               /* s1 == s2 */
X}
X#endif
X
X#ifndef max
X# define max(a, b) ((a) > (b) ? (a) : (b))
X#endif
X#ifndef min
X# define min(x,y) ((x) < (y) ? (x) : (y))
X#endif
X
Xchar *copyright_text[]={
X"NetHack, Copyright 1985, 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993.",
X"         By Stichting Mathematisch Centrum and M. Stephenson.",
X"         See license for details.",
X0
X};
X
X#ifdef CLI
X
Xmain( argc, wbs )
X    int argc;
X    struct WBStartup *wbs;
X{
X    GPTR gptr;
X    BPTR lc,lc2;
X    struct FileInfoBlock finfo;
X    char *name;
X    char namebuf[50];
X    char **argv=(char **)wbs;
X
X    ZapOptions( curopts );
X    InitWB( argc, (struct WBStartup *)argv );
X    errmsg( NO_FLASH, "Welcome to NetHack Version 3.1!\n" );
X    CopyRight( );
X
X    ReadConfig( );
X
X    /* Wait till user quits */
X
X    while( !quit )
X    {
X    char tbuf[8];
X    char *p=tbuf;
X    char *dirname=cnfsavedir;
X/* play a game */
X    {
X        int c;
X        argline[0]='\0';
X        name="NewGame.info";        /* this will fail - it's in NetHack: */
X        for(c=1;c<argc;c++){
X        /* slow but easy - not a critical path */
X        strcpy(eos(argline),argv[c]);
X        if(!strncmp(argv[c],"-u",2)){
X            if(!strcmp(argv[c],"-u")){
X            name= argv[c+1];
X            }else{
X            name= &argv[c][1];
X            }
X        }
X        if(c<argc)strcpy(eos(argline)," ");
X        }
X        eos(argline)[-1]='\0';
X    }
X    strcpy(namebuf,cnfsavedir);
X    condaddslash(namebuf);
X    strcpy(eos(namebuf),name);
X    lc=Lock(namebuf,ACCESS_READ);
X    if(!lc){
X        dirname="NetHack:";
X        strcpy(namebuf,dirname);
X        strcpy(eos(namebuf),"NewGame.info");
X        lc=Lock(namebuf,ACCESS_READ);
X        if(!lc){
X        errmsg(NO_FLASH,"can't find NewGame.info");
X        cleanup(1);
X        }
X    }
X    Examine(lc,&finfo);
X    lc2=ParentDir(lc);
X    UnLock(lc);
X    gptr=GetWBIcon(lc2,dirname,&finfo);
X    UnLock(lc2);
X    run_game(gptr);
X
X/* wait for game to end */
X    WaitEOG(gptr);
X    FreeGITEM(gptr);
X/* ask about another? */
X    printf("Play again? [yn] ");
X    fgets(tbuf,sizeof(tbuf),stdin);
X    while(*p && isspace(*p))p++;
X    switch(*p){
X    case 'n':
X    case 'N':
X        quit=1;
X    }
X    }
X    cleanup(0);
X}
X
X/* CLI */
X
Xvoid
XWaitEOG(target)
X    GPTR target;
X{
X    long mask, rmask;
X    struct WBStartup *wbs;
X    struct WBArg *wba;
X    int i;
X    /* Get a message */
X    while(1){
X    mask = ( 1L << dosport->mp_SigBit ) ;
X    rmask = Wait( mask );
X
X
X    if( rmask & ( 1L << dosport->mp_SigBit ) )
X    {
X        /* Get process termination messages */
X
X        while( wbs = (struct WBStartup *) GetMsg( dosport ) )
X        {
X        /* Find the game that has terminated */
X
X        if(target->seglist == wbs->sm_Segment)
X        {
X#ifdef SPLIT
X            if(!running_split)
X#endif
X            /* Unload the code */
X            UnLoadSeg( wbs->sm_Segment );
X            /* Free the startup message resources */
X
X            wba = (struct WBArg *)
X            ((long)wbs + sizeof( struct WBStartup ));
X            for( i = 0; i < wbs->sm_NumArgs; ++i )
X            {
X            FreeMem( wba[i].wa_Name, strlen( wba[i].wa_Name ) + 1 );
X            UnLock( wba[i].wa_Lock );
X            }
X            FreeMem( wbs, wbs->sm_Message.mn_Length );
X            wbs = NULL;
X
X            return;
X        }
X        }
X
X    }
X    }
X}
X
X/* CLI */
X
Xvoid CopyRight()
X{
X    int line;
X    for(line=0;copyright_text[line];line++){
X    printf("%s\n",copyright_text[line]);
X    }
X}
X
X/* CLI */
X
X/*
X * Do the one time initialization things.
X */
X
Xvoid
XInitWB( argc, wbs )
X    int argc;
X    register struct WBStartup *wbs;
X{
X
X    /* Open Libraries */
X    GfxBase= (struct GfxBase *) OldOpenLibrary("graphics.library");
X    IconBase= OldOpenLibrary("icon.library");
X    DiskfontBase= (struct DiskfontBase *)OldOpenLibrary("diskfont.library");
X    IntuitionBase= (struct IntuitionBase *)OldOpenLibrary("intuition.library");
X
X    if(!GfxBase || !IconBase || !DiskfontBase || !IntuitionBase)
X    {
X    error("library open failed");
X    cleanup( 1 );
X    }
X
X    /* Get Port for replied WBStartup messages */
X
X    if( ( dosport = CreatePort( NULL, 0 ) ) == NULL )
X    {
X    error("failed to create dosport" );
X    cleanup( 1 );
X    }
X
X    /* If started from CLI */
X    if( argc == 0 ){
X    printf("Run this program from CLI only.\n");
X    DisplayBeep(0);     /* could be more specific */
X    Delay(400);
X    cleanup(1);
X    }
X}
X
X/* CLI */
X
X/*
X * Read a nethack.cnf like file and collect the configuration
X * information from it.
X */
Xvoid ReadConfig()
X{
X    register FILE *fp;
X    register char *buf, *t;
X
X    /* Use a dynamic buffer to limit stack use */
X
X    if( ( buf = xmalloc( 1024 ) ) == NULL )
X    {
X    error( "Can't alloc space to read config file" );
X    cleanup( 1 );
X    }
X
X    /* If the file is not there, can't load it */
X
X    if( ( fp = fopen( NetHackCnf, "r" ) ) == NULL )
X    {
X    errmsg( FLASH, "Can't load config file %s", NetHackCnf );
X    free( buf );
X    return;
X    }
X
X    /* Read the lines... */
X
X    while( fgets( buf, 1024, fp ) != NULL )
X    {
X    if( *buf == '#' )
X        continue;
X
X    if( ( t = strchr( buf, '\n' ) ) != NULL )
X        *t = 0;
X
X    if( strnicmp( buf, "SAVE=", 5 ) == 0 )
X    {
X        cnfsavedir=strdup(buf+5);
X    }
X    else
X    {
X        /* We don't care about the rest */
X    }
X    }
X    fclose( fp );
X    free( buf );
X}
X
X/* CLI */
X
Xvoid
Xrun_game( gptr )
X    register GPTR gptr;
X{
X    struct Task *ctask;
X    register struct MsgPort *proc = NULL;
X    int tidx;
X
X    tidx = 0;
X
X    gptr->gname = xmalloc( 20 + strlen( gptr->name ) );
X
X    SetToolLine(gptr, "INTERNALCLI", argline);
X    gptr->wbs = AllocMem( sizeof( struct WBStartup ) +
X    ( sizeof( struct WBArg ) * 2 ), MEMF_PUBLIC | MEMF_CLEAR );
X
X    /* Check if we got everything */
X
X    if( !gptr->gname || !gptr->wbs )
X    {
X    fprintf( stderr, "Can't allocate memory\n" );
X    goto freemem;
X    }
X
X    /* Get the arguments structure space */
X
X    gptr->wba = ( struct WBArg * ) ((long)gptr->wbs +
X    sizeof( struct WBStartup ) );
X    /* Load the game into memory */
X#ifdef SPLIT
X    /* Which version do we run? */
X    {
X    char gi[80];
X    BPTR tmplock;
X
X    sprintf( gi, "%s.dir", GAMEIMAGE );
X    tmplock=Lock( gi, ACCESS_READ );
X    if( tmplock ){
X    UnLock( tmplock );
X    gptr->seglist = (BPTR)s_LoadSeg( gi );
X    if(gptr->seglist)running_split=1;
X    }else{
X    gptr->seglist = (BPTR)LoadSeg( GAMEIMAGE );
X    }
X    }
X#else
X    gptr->seglist = (BPTR)LoadSeg( GAMEIMAGE );
X#endif
X
X    if( gptr->seglist == NULL)
X    {
X    errmsg( FLASH, "Can't load %s", GAMEIMAGE );
X    goto freemem;
X    }
X
X    /* Set the game name for the status command */
X    sprintf( gptr->gname, "NetHack 3.1 %s", gptr->name );
X
X    /* Create a process for the game to execute in */
X    ctask = FindTask( NULL );
X    proc = CreateProc( gptr->gname, ctask->tc_Node.ln_Pri,
X            gptr->seglist, GAMESTACK );
X
X    /* Check if the create failed */
X
X    if( proc == NULL )
X    {
X    fprintf(stderr, "Error creating process %d\n", IoErr() );
X#ifdef SPLIT
X    if(!running_split)
X#endif
X        UnLoadSeg( gptr->seglist );
Xfreemem:
X    if( gptr->gname ) free( gptr->gname );
X    gptr->gname = NULL;
X
X    if( gptr->wbs ) FreeMem( gptr->wbs,
X        sizeof( struct WBStartup ) + sizeof( struct WBArg ) * 2 );
X    gptr->wbs = NULL;
X    return;
X    }
X
X    /* Get the Process structure pointer */
X    gptr->prc = (struct Process *) (((long)proc) - sizeof( struct Task ));
X
X    /* Set the current directory */
X    gptr->prc->pr_CurrentDir=((struct Process *)FindTask(NULL))->pr_CurrentDir;
X
X    /* Fill in the startup message */
X    gptr->wbs->sm_Process = proc;
X    gptr->wbs->sm_Segment = gptr->seglist;
X    gptr->wbs->sm_NumArgs = 2;
X    gptr->wbs->sm_ToolWindow = "con:0/0/100/300/NetHack 3.1";
X    gptr->wbs->sm_ArgList = gptr->wba;
X
X    /* Fill in the args */
X
X    gptr->wba[0].wa_Name = Strdup( GAMEIMAGE );
X    gptr->wba[0].wa_Lock = Lock( dirname( GAMEIMAGE ), ACCESS_READ );
X
X    gptr->wba[1].wa_Name = Strdup( gptr->name );
X    gptr->wba[1].wa_Lock = Lock( gptr->dname, ACCESS_READ );
X
X    /* Write the updated tools types entries */
X
X    WriteDObj( gptr, gptr->wba[1].wa_Lock );
X
X    /* Set the message fields correctly */
X
X    gptr->wbs->sm_Message.mn_Node.ln_Type = NT_MESSAGE;
X    gptr->wbs->sm_Message.mn_Node.ln_Pri = 0;
X    gptr->wbs->sm_Message.mn_ReplyPort = dosport;
X    gptr->wbs->sm_Message.mn_Length =
X    sizeof( struct WBStartup ) + ( sizeof( struct WBArg ) * 2 );
X
X    /* Send the WB Startup message to let the game go... */
X
X    PutMsg( proc, &gptr->wbs->sm_Message );
X}
X
X#else   /* CLI */
X
Xvoid RPText( rp, s )
X    struct RastPort *rp;
X    register char *s;
X{
X    Text( rp, s, strlen( s ) );
X}
X
X/* !CLI */
X
Xvoid
XSetUpMenus( mp, scrn )
X    register struct Menu *mp;
X    register struct Screen *scrn;
X{
X    register struct MenuItem *mip;
X    register int i, leftoff = 0, horiz=0, len;
X    register int com, chk;
X
X    for( ; mp; mp = mp->NextMenu )
X    {
X    i = 0;
X    horiz = (scrn->RastPort.TxWidth*strlen(mp->MenuName))+16;
X    /*mp->LeftEdge = leftoff;*/
X    com = chk = 0;
X    for( mip = mp->FirstItem; mip; mip = mip->NextItem )
X    {
X        if( mip->Flags & COMMSEQ )
X        com = scrn->RastPort.TxWidth * 6;
X        if( mip->Flags & CHECKIT )
X        chk = scrn->RastPort.TxWidth * 3;
X    }
X    for( mip = mp->FirstItem; mip; mip = mip->NextItem )
X    {
X        mip->Height = scrn->RastPort.TxHeight;
X        mip->TopEdge = scrn->RastPort.TxHeight * i++;
X
X        len = IntuiTextLength((struct IntuiText *)
X            (mip->ItemFill))+8+com+chk;
X        horiz = max( horiz,len );
X    }
X
X    for( mip = mp->FirstItem; mip; mip = mip->NextItem )
X    {
X        mip->Width = horiz;
X    }
X    leftoff += horiz;
X    }
X}
X
X/* !CLI */
X
X/* Get a text line from the indicated file based on an array of per
X * line offsets.
X */
X
Xvoid getline( fp, offarr, which, buf, size )
X    FILE *fp;
X    long *offarr;
X    int which, size;
X    char *buf;
X{
X    fseek( fp, offarr[ which ], 0 );
X    fgets( buf, size, fp );
X}
X
X/* !CLI */
X
Xvoid
Xdo_closewindow()
X{
X    /*set close flag - cleanup must be done elsewhere*/
X    cleanup( 0 );
X}
X
X/* !CLI */
X
Xvoid
Xmenu_copyopt()
X{
X    GPTR gptr;
X    char newname[ 100 ], oldname[ 100 ], cmd[ 200 ];
X
X    if( ( gptr = NeedGame() ) == NULL )
X    return;
X
X    if( StrRequest( "Enter new player name", newname, gptr->fname ) == 0 )
X    return;
X
X    if( strcmp( newname, gptr->fname ) == 0 )
X    {
X    errmsg( FLASH, "Copying aborted, new name same as old" );
X    return;
X    }
X
X    strcpy( oldname, GameName( gptr, NULL ) );
X    strcpy( newname, GameName( gptr, newname ) );
X
X    sprintf( cmd, "c:copy \"%s\" \"%s\"", oldname, newname );
X    Execute( cmd, NULL, NULL );
X    MapGadgets( R_DISK, 1 );
X}
X
X/* !CLI */
X
Xvoid
Xmenu_rename()
X{
X    register GPTR gptr;
X    char newname[ 100 ], oldname[ 100 ], cmd[ 200 ], name[100], *t;
X
X    if( ( gptr = NeedGame() ) == NULL )
X    return;
X
X    strcpy( newname, gptr->name );
X    if( t = strrchr( newname, '.' ) )
X    {
X    if( strcmp( t, ".sav" ) == 0 )
X        *t = 0;
X    }
X
X    if( StrRequest( "Enter New Name For Game", name, newname ) == 0)
X    return;
X
X    /* Name can only be this long to allow inclusion of appropriate suffix */
X    name[ 30 - strlen( ".sav.info " ) ] = '\0';
X
X    if( strcmp( name, newname ) == 0 )
X    {
X    errmsg( FLASH, "Rename aborted, name unchanged from %s", newname );
X    return;
X    }
X
X    strcat( name, ".sav" );
X
X    strcpy( oldname, GameName( gptr, NULL ) );
X
X    strcpy( newname, GameName( gptr, name ) );
X    strcat( newname, ".info" );
X
X    /* Rename icon file */
X    sprintf( cmd, "c:rename \"%s\" \"%s\"", oldname, newname );
X    Execute( cmd, NULL, NULL );
X
X    strcpy( oldname, GameName( gptr, gptr->name ) );
X
X    strcpy( newname, GameName( gptr, name ) );
X
X    /* Rename save file if it is actually there */
X    if( access( oldname, 0 ) == 0 )
X    {
X    sprintf( cmd, "c:rename \"%s\" \"%s\"", oldname, newname );
X    Execute( cmd, NULL, NULL );
X    }
X
X    MapGadgets( R_DISK, 1 );
X}
X
X#endif  /* CLI */
X
Xvoid CleanUpLists( )
X{
X    register GPTR gptr;
X
X    while( gptr = gamehead )
X    {
X    gamehead = gamehead->next;
X    FreeGITEM( gptr );
X    }
X
X    while( gptr = gameavail )
X    {
X    gameavail = gameavail->next;
X    free( gptr );
X    }
X}
X
X#ifndef CLI
X
Xvoid SafeCloseWindow( window )
X    register struct Window *window;
X{
X    register struct Message *msg;
X
X    if( !window )
X    return;
X
X    /* Remove any attached menu */
X
X    if( window->MenuStrip )
X    {
X    ClearMenuStrip( window );
X    }
X
X    Forbid();
X    while( window->UserPort != NULL &&
X        ( msg = GetMsg( window->UserPort) ) != NULL )
X    {
X    ReplyMsg( msg );
X    }
X
X    CloseWindow( window );
X    Permit();
X}
X
X#else   /* CLI */
X
Xvoid CloseLibraries( )
X{
X    if( IntuitionBase )     CloseLibrary( (void *) IntuitionBase );
X    IntuitionBase = 0;
X    if( DiskfontBase )      CloseLibrary( (void *) DiskfontBase );
X    DiskfontBase = 0;
X    if( IconBase )          CloseLibrary(  IconBase );
X    IconBase = 0;
X    if( GfxBase )           CloseLibrary( (void *) GfxBase );
X    GfxBase = 0;
X}
X
X/* CLI */
X
Xvoid cleanup( code )
X    int code;
X{
X    if( dosport ) DeletePort( dosport );
X    dosport = NULL;
X
X    CleanUpLists( );
X    CloseLibraries( );
X
X#ifdef SPLIT
X    if(running_split){
X    s_UnLoadSeg();
X    }
X#endif
X    exit( code );
X}
X
X/* CLI */
X
XGPTR AllocGITEM( )
X{
X    register GPTR gptr;
X
X    if( gameavail )
X    {
X    gptr = gameavail;
X    gameavail = gameavail->next;
X    }
X    else
X    {
X    gptr = xmalloc( sizeof( GAMEITEM ) );
X    }
X
X    if( gptr )
X    memset( gptr, 0, sizeof( GAMEITEM ) );
X
X    return( gptr );
X}
X
X/* CLI */
X
Xvoid FreeGITEM( gptr )
X    register GPTR gptr;
X{
X    /* Free all of the pieces first */
X
X    if( gptr->talloc )
X    FreeTools( gptr );
X
X    if( gptr->dobj )
X    FreeDObj( gptr->dobj );
X
X    gptr->dobj = NULL;
X
X    if( gptr->name )
X    free( gptr->name );
X    gptr->name = NULL;
X
X    if( gptr->dname )
X    free( gptr->dname );
X    gptr->dname = NULL;
X
X    if( gptr->fname )
X    free( gptr->fname );
X    gptr->fname = NULL;
X
X    /* Connect it to free list */
X
X    gptr->next = gameavail;
X    gameavail = gptr;
X}
X
X/* CLI */
X
Xstruct DiskObject *AllocDObj( str )
X    register char *str;
X{
X    register struct DiskObject *doptr;
X    register char *t, *t1;
X
X    if( ( t = strrchr( str, '.' ) ) && stricmp( t, ".info" ) == 0 )
X    {
X    *t = 0;
X    } else {
X    t = NULL;
X    }
X
X    if( doptr = GetDiskObject( str ) )
X    {
X    struct IntuiText *ip;
X
X    diskobj_filter(doptr);  /* delete all but INTERNALCLI */
X
X    if( ip = xmalloc( sizeof( struct IntuiText ) ) )
X    {
X        memset( ip, 0, sizeof( struct IntuiText ) );
X        ip->FrontPen = C_BLACK;
X        ip->DrawMode = JAM1;
X        ip->IText = strdup( str );
X        doptr->do_Gadget.GadgetText = ip;
X
X        /* Trim any .sav off of the end. */
X
X        if( ( t1 = strrchr( ip->IText, '.' ) ) &&
X        stricmp( t1, ".sav" ) == 0 )
X        {
X        *t1 = 0;
X        ip->LeftEdge = (2 * win->RPort->TxWidth);
X        }
X        }
X    }
X    if( t ) *t = '.';
X
X    return( doptr );
X}
X
X#endif  /* CLI */
X
Xvoid FreeDObj( doptr )
X    register struct DiskObject *doptr;
X{
X    if( doptr->do_Gadget.GadgetText )
X    {
X    free( doptr->do_Gadget.GadgetText->IText );
X    free( doptr->do_Gadget.GadgetText );
X    }
X    doptr->do_Gadget.GadgetText = NULL;
X    FreeDiskObject( doptr );
X}
X
X#ifdef CLI
X#ifdef AZTEC_C
Xvoid errmsg(int flash, char *str, ...)
X#else
Xvoid errmsg( flash, str )
Xchar *str;
Xint flash;
X#endif
X{
X    va_list vp;
X
X    va_start( vp, str );
X
X/*  if( !win || !wbopen ) */
X    {
X    vprintf( str, vp );
X    va_end( vp );
X    return;
X    }
X
X}
X
X/* CLI */
X
X/*
X * Issue an error message to the users window because it can not be done
X * any other way.
X */
X
Xvoid error( str )
X    register char *str;
X{
X    char s[ 50 ];
X    if( scrn ) ScreenToBack( scrn );
X    Delay( 10 );
X    fprintf( stderr, "%s\n", str );
X    fprintf( stderr, "Hit Return: " );
X    fflush( stderr );
X    gets( s );
X    if( scrn ) ScreenToFront( scrn );
X}
X
X#else   /* CLI */
X
Xvoid menu_scores()
X{
X    register char buf1[50];
X    register char **oldtools;
X    register GPTR gptr;
X    int oldalloc;
X    extern GPTR windowgads;
X
X    if( StrRequest( "Scores for whom?", buf1, "all" ) != 0 )
X    {
X    for( gptr = windowgads; gptr; gptr = gptr->nextwgad )
X    {
X        if( gptr->dobj->do_Gadget.GadgetID == GADNEWGAME )
X        break;
X    }
X
X    if( !gptr )
X    {
X        errmsg( FLASH, "Can't find NewGame icon" );
X        return;
X    }
X
X    /* Save current tools */
X    oldtools = gptr->dobj->do_ToolTypes;
X
X    /* Force a new tooltypes array to be allocated */
X    if( oldalloc = gptr->talloc )
X    {
X        gptr->dobj->do_ToolTypes = gptr->otools;
X        gptr->talloc = 0;
X    }
X
X    /* Add the scores entry */
X        SetToolLine( gptr, "SCORES", *buf1 ? buf1 : "all" );
X
X    /* Get the scores */
X    run_game( gptr );
X
X    /* Free the tools which contain "SCORES=" */
X    FreeTools( gptr );
X
X    /* Restore the old tools.  When this game exits, the tools
X     * will be written back out to disk to update things
X     */
X    gptr->dobj->do_ToolTypes = oldtools;
X    gptr->talloc = oldalloc;
X    Delay( 100 );
X    UpdateGameIcon( gptr );
X    }
X}
X
X/* !CLI */
X
XCheckAndCopy( gadstr, origstr )
X    char *gadstr, *origstr;
X{
X    char *t;
X    int i;
X
X    if( t = strchr( gadstr, '=' ) )
X    {
X    i = t - gadstr;
X    /* Check for original string and don't allow one line to be replaced with
X     * another.
X     */
X    if( *origstr != 0 && strncmp( gadstr, origstr, i ) != 0 )
X    {
X        strcpy( gadstr, origstr );
X        DisplayBeep( NULL );
X        return( 0 );
X    }
X    }
X    else
X    {
X    /* If added an equals, there wasn't one previously, so signal an error */
X    if( t = strchr( origstr, '=' ) )
X    {
X        strcpy( gadstr, origstr );
X        DisplayBeep( NULL );
X        return( 0 );
X    }
X    }
X    return( 1 );
X}
X
X/* !CLI */
X
Xint IsEditEntry( str, gptr )
X    char *str;
X    register GPTR gptr;
X{
X    if( gptr->dobj->do_Gadget.GadgetID == GADNEWGAME )
X    return( 1 );
X    if( strncmp( str, "CHARACTER=", 10 ) == 0 )
X    return( 0 );
X    return( 1 );
X}
X
X/* !CLI */
X
Xvoid menu_comment( )
X{
X    register GPTR gptr;
X    struct FileInfoBlock *finfo;
X    BPTR lock;
X    char commentstr[ 100 ];
X
X    if( ( gptr = NeedGame() ) == NULL )
X    return;
X
X    if( ( lock = Lock( GameName( gptr, NULL ), ACCESS_READ ) ) == NULL )
X    {
X    /* Can't get lock, reload and return */
X
X    errmsg( FLASH, "Can't Lock game save file: %s",
X            GameName( gptr, NULL ) );
X    MapGadgets( R_DISK, 1 );
X    return;
X    }
X
X    finfo = (struct FileInfoBlock *) xmalloc(sizeof(struct FileInfoBlock));
X    Examine( lock, finfo );
X    UnLock( lock );
X    strncpy( commentstr, finfo->fib_Comment, sizeof( finfo->fib_Comment ) );
X    commentstr[ sizeof( finfo->fib_Comment ) ] = 0;
X    free( finfo );
X
X    /* Set the correct size */
X    if( StrRequest( "Edit Comment as Desired",
X        commentstr, commentstr ) == 0 )
X    {
X    return;
X    }
X
X    SetComment( GameName( gptr, NULL ), commentstr );
X}
X
X/* !CLI */
X
X/*
X * Make the proportional gadget position match the values passed
X */
X
Xvoid UpdatePropGad( win, gad, vis, total, top )
X    struct Window *win;
X    struct Gadget *gad;
X    register long vis, total, top;
X{
X    register long hidden;
X    register int body, pot;
X
X    hidden = max( total-vis, 0 );
X
X    if( top > hidden )
X    top = hidden;
X
X    if( hidden > 0 )
X    body = (ULONG) (vis * MAXBODY) / total;
X    else
X    body = MAXBODY;
X
X    if( hidden > 0 )
X    pot = (top * MAXPOT) / hidden;
X    else
X    pot = 0;
X
X    NewModifyProp( gad, win, NULL,
X        AUTOKNOB|FREEHORIZ, pot, 0, body, MAXBODY, 1 );
X}
X
X#endif  /* CLI */
X
X/*
X * Allocate some memory
X */
X
Xvoid *xmalloc( nbytes )
X    unsigned nbytes;
X{
X    return( malloc( nbytes ) );
X}
X
X#ifndef CLI
X/*
X * Delete the game associated with the GAME structure passed
X */
X
Xint DeleteGame( gptr )
X    register GPTR gptr;
X{
X    register int err;
X
X    err = DeleteFile( GameName( gptr, gptr->name ) );
X    err += DeleteFile( GameName( gptr, NULL ) );
X    return( err );
X}
X#endif  /* CLI */
X
X/*
X * Look through the list of games for one named 'name'
X */
X
XGPTR FindGame( name )
X    char *name;
X{
X    register GPTR gptr;
X
X    for( gptr = gamehead; gptr; gptr = gptr->next )
X    {
X    if( stricmp( gptr->fname, name ) == 0 )
X        break;
X    }
X
X    return( gptr );
X}
X/*
X * Set the option string indicated by idx to 'str'
X */
X
Xvoid setoneopt( idx, str )
X    int idx;
X    char *str;
X{
X    /* This space accumulates, but is recovered at process exit */
X
X    options[ idx ] = strdup( str );
X}
X
X/*
X * Get just the directory name of str
X */
X
Xchar *dirname( str )
X    char *str;
X{
X    static char buf[ 300 ];
X    char *t;
X
X    strncpy( buf, str, sizeof( buf ) );
X    buf[ sizeof( buf ) - 1 ] = 0;
X
X    if( (t = strrchr( buf, '/' ) ) == NULL ||
X        (t = strrchr( buf, ':' ) ) == NULL )
X    {
X    return( "/" );
X    }
X    *t = 0;
X    return( buf );
X}
X
X#ifndef CLI
X
X/*
X * Make sure that only itemno is checked in 'menu' off of menuptr
X */
X
Xvoid CheckOnly( menuptr, menu, itemno )
X    register struct Menu *menuptr;
X    register int menu, itemno;
X{
X    register struct MenuItem *ip;
X
X    while( menuptr && menu-- )
X    menuptr = menuptr->NextMenu;
X
X    if( menuptr )
X    {
X    for( ip = menuptr->FirstItem; ip && itemno; itemno--)
X    {
X        ip->Flags &= ~CHECKED;
X        ip = ip->NextItem;
X    }
X
X    if( ip )
X    {
X        ip->Flags |= CHECKED;
X        ip = ip->NextItem;
X    }
X
X    while( ip )
X    {
X        ip->Flags &= ~CHECKED;
X        ip = ip->NextItem;
X    }
X    }
X}
X
X/* !CLI */
X
Xint FindChecked( menuptr, menu )
X    register struct Menu *menuptr;
X    register int menu;
X{
X    register int itemno;
X    register struct MenuItem *ip;
X
X    while( menuptr && menu-- )
X    menuptr = menuptr->NextMenu;
X
X    if( menuptr )
X    {
X    for( itemno = 0, ip = menuptr->FirstItem; ip; ip = ip->NextItem )
X    {
X        if( ip->Flags & CHECKED )
X        return( itemno );
X        ++itemno;
X    }
X    }
X    return( 0 );
X}
X
X/* !CLI */
X
X/*
X * Create a file name based in the GAMEs directory.  If file is NULL,
X * the file name is the icon file.  Otherwise it is 'file'.
X */
X
Xchar *GameName( gptr, file )
X    GPTR gptr;
X    char *file;
X{
X    static char buf[200];
X
X    if( file == NULL )
X    file = gptr->fname;
X
X    if( strchr( "/:", gptr->dname[ strlen( gptr->dname ) - 1 ] ) )
X    sprintf( buf, "%s%s", gptr->dname, file );
X    else
X    sprintf( buf, "%s/%s", gptr->dname, file );
X    return( buf );
X}
X
X#endif  /* CLI */
X
X/*
X * Allocate a new GAME structure for the file passed and fill it in
X */
X
XGPTR GetWBIcon( lock, dir, finfo )
X    register BPTR lock;
X    register char *dir;
X    register struct FileInfoBlock *finfo;
X{
X    register BPTR odir;
X    register char *t;
X    register GPTR gptr;
X
X    if( ( gptr = AllocGITEM( ) ) == NULL )
X    goto noitems;
X
X    if( ( gptr->dname = strdup( dir ) ) == NULL )
X    goto outofmem;
X
X    if( ( gptr->fname = strdup( finfo->fib_FileName ) ) == NULL )
X    goto outofmem;
X
X    /* Strip the .info off. */
X    if( t = strrchr( finfo->fib_FileName, '.' ) )
X    {
X    if( stricmp( t, ".info" ) == 0 )
X        *t = 0;
X    else
X        t = NULL;
X    }
X
X    if( ( gptr->name = strdup( finfo->fib_FileName ) ) == NULL )
X    goto outofmem;
X
X    /* If removed .info, put it back */
X
X    if( t )
X    *t = '.';
X
X    /* Change to saved game directory */
X
X    odir = CurrentDir( lock );
X
X    /* Allocate a diskobj structure */
X
X    if( ( gptr->dobj = AllocDObj( finfo->fib_FileName ) ) == NULL )
X    {
X    (void) CurrentDir( odir );
Xoutofmem:
X    FreeGITEM( gptr );
X
X    if( gptr->fname )
X        free( gptr->fname );
X    gptr->fname = NULL;
X
X    if( gptr->name )
X        free( gptr->name );
X    gptr->name = NULL;
X
X    if( gptr->dname )
X        free( gptr->dname );
X    gptr->dname = NULL;
X
Xnoitems:
X    errmsg( FLASH, "Can't get Disk Object: %s", finfo->fib_FileName );
X    return( NULL );
X    }
X    gptr->oflag = gptr->dobj->do_Gadget.Flags;
X    gptr->oact = gptr->dobj->do_Gadget.Activation;
X    gptr->dobj->do_Gadget.Activation |=
X        ( RELVERIFY | GADGIMMEDIATE | FOLLOWMOUSE );
X    gptr->dobj->do_Gadget.Flags &= ~(GADGHIGHBITS);
X    gptr->dobj->do_Gadget.Flags |= GADGHNONE;
X
X    /* Make sure gptr->dobj->do_ToolTypes is not NULL */
X    ReallocTools( gptr, 0 );
X
X    (void) CurrentDir( odir );
X    return( gptr );
X}
X
X#ifndef CLI
X
X/*
X * Put a 3-D motif border around the gadget.  String gadgets or those
X * which do not have highlighting are rendered down.  Boolean gadgets
X * are rendered in the up position by default.
X */
X
Xvoid SetBorder( gd, val )
X    register struct Gadget *gd;
X    int val;
X{
X    register struct Border *bp;
X    register short *sp;
X    register int i;
X    int borders = 6;
X
X    /* Allocate two border structures one for up image and one for down
X     * image, plus vector arrays for the border lines.
X     */
X
X    if( gd->GadgetType == STRGADGET )
X    borders = 12;
X
X    if( ( bp = xmalloc( ( ( sizeof( struct Border ) * 2 ) +
X        ( sizeof( short ) * borders ) ) * 2 ) ) == NULL )
X    {
X    return;
X    }
X
X    /* Remove any special rendering flags to avoid confusing intuition
X     */
X
X    gd->Flags &= ~(GADGHIGHBITS|GADGIMAGE|GRELWIDTH|
X            GRELHEIGHT|GRELRIGHT|GRELBOTTOM);
X
X    sp = (short *)(bp + 4);
X    if( val == 0 || val == 2 ||
X    gd->GadgetType == STRGADGET || ( gd->GadgetType == BOOLGADGET &&
X        ( gd->Flags & GADGHIGHBITS ) == GADGHNONE ) )
X    {
X    /* For a string gadget, we expand the border beyond the area where
X     * the text will be entered.
X     */
X
X    sp[0] = -1;
X    sp[1] = gd->Height - 1;
X    sp[2] = -1;
X    sp[3] = -1;
X    sp[4] = gd->Width - 1;
X    sp[5] = -1;
X
X    sp[6] = gd->Width + 1;
X    sp[7] = -2;
X    sp[8] = gd->Width + 1;
X    sp[9] = gd->Height + 1;
X    sp[10] = -2;
X    sp[11] = gd->Height + 1;
X
X    sp[12] = -2;
X    sp[13] = gd->Height;
X    sp[14] = -2;
X    sp[15] = -2;
X    sp[16] = gd->Width;
X    sp[17] = -2;
X    sp[18] = gd->Width;
X    sp[19] = gd->Height;
X    sp[20] = -2;
X    sp[21] = gd->Height;
X
X    for( i = 0; i < 3; ++i )
X    {
X        bp[ i ].LeftEdge = bp[ i ].TopEdge = -1;
X        if( val == 2 )
X        bp[ i ].FrontPen = ( i == 0 || i == 1 ) ? C_WHITE : C_BLACK;
X        else
X        bp[ i ].FrontPen = ( i == 0 || i == 1 ) ? C_BLACK : C_WHITE;
X
X        /* Have to use JAM2 so that the old colors disappear. */
X        bp[ i ].BackPen = C_GREY;
X        bp[ i ].DrawMode = JAM2;
X        bp[ i ].Count = ( i == 0 || i == 1 ) ? 3 : 5;
X        bp[ i ].XY = &sp[ i*6 ];
X        bp[ i ].NextBorder = ( i == 2 ) ? NULL : &bp[ i + 1 ];
X    }
X
X    /* Set the up image */
X    gd->GadgetRender = (APTR) bp;
X
X    /* Same image for select image */
X    gd->SelectRender = (APTR) bp;
X
X    gd->LeftEdge++;
X    gd->TopEdge++;
X    gd->Flags |= GADGHCOMP;
X    }
X    else
X    {
X    /* Create the border vector values for up and left side, and
X     * also the lower and right side.
X     */
X
X    sp[0] = 0;
X    sp[1] = gd->Height;
X    sp[2] = 0;
X    sp[3] = 0;
X    sp[4] = gd->Width;
X    sp[5] = 0;
X
X    sp[6] = gd->Width;
X    sp[7] = 0;
X    sp[8] = gd->Width;
X    sp[9] = gd->Height;
X    sp[10] = 0;
X    sp[11] = gd->Height;
X
X    /* We are creating 4 sets of borders, the two sides of the
X     * rectangle share the border vectors with the opposite image,
X     * but specify different colors.
X     */
X
X    for( i = 0; i < 4; ++i )
X    {
X        bp[ i ].TopEdge = bp[ i ].LeftEdge = 0;
X
X        /* A GADGHNONE is always down */
X
X        if( val != 3 && gd->GadgetType == BOOLGADGET &&
X        ( gd->Flags & GADGHIGHBITS ) != GADGHNONE )
X        {
X        bp[ i ].FrontPen =
X            ( i == 1 || i == 2 ) ? C_BLACK : C_WHITE;
X        }
X        else
X        {
X        bp[ i ].FrontPen =
X            ( i == 1 || i == 3 ) ? C_WHITE : C_BLACK;
X        }
X
X        /* Have to use JAM2 so that the old colors disappear. */
X        bp[ i ].BackPen = C_GREY;
X        bp[ i ].DrawMode = JAM2;
X        bp[ i ].Count = 3;
X        bp[ i ].XY = &sp[ 6 * ((i &1) != 0) ];
X        bp[ i ].NextBorder =
X        ( i == 1 || i == 3 ) ? NULL : &bp[ i + 1 ];
X    }
X
X    /* bp[0] and bp[1] two pieces for the up image */
X    gd->GadgetRender = (APTR) bp;
X
X    /* bp[2] and bp[3] two pieces for the down image */
X    gd->SelectRender = (APTR) (bp + 2);
X    gd->Flags |= GADGHIMAGE;
X    }
X}
X
X/* !CLI */
X
Xstruct Gadget *FindGadget( window, newwindow, id )
X    struct Window *window;
X    struct NewWindow *newwindow;
X    int id;
X{
X    struct Gadget *gd = NULL;
X
X    if( window )
X    gd = window->FirstGadget;
X    else if( newwindow )
X    gd = newwindow->FirstGadget;
X
X    while( gd )
X    {
X    if( gd->GadgetID == id )
X        break;
X    gd = gd->NextGadget;
X    }
X
X    return( gd );
X}
X
X#endif  /* CLI */
X
X/*
X * Clear all previous values from passed options array
X */
Xvoid ZapOptions( optr )
X    OPTR optr;
X{
X    int i;
X
X    for( i = 0; optr[ i ].name; ++i )
X    {
X    if( optr[i].optstr )
X    {
X        if( *optr[i].optstr )
X        {
X        free( optr[i].optstr );
X        optr[i].optstr = "";
X        }
X    }
X    else
X    {
X        optr[i].optval = optr[i].defval;
X    }
X    }
X}
X
X#ifndef CLI
X
X/*
X * Copy Options from GAMES OPTIONS= tooltypes element to the gadgets
X */
Xvoid CopyOptions( optr, gptr )
X    OPTR optr;
X    GPTR gptr;
X{
X    char **sp;
X
X    for( sp = gptr->dobj->do_ToolTypes; *sp; ++sp )
X    {
X    if( strnicmp( *sp, "options=", 8 ) == 0 )
X    {
X        break;
X    }
X    }
X
X    if( *sp == NULL )
X    {
X    errmsg( NO_FLASH, "Options not set for %s", gptr->name );
X    return;
X    }
X
X    CopyOptionStr( optr, *sp + 8 );
X}
X
X/* !CLI */
X
Xvoid CopyOptionStr( optr, str )
X    OPTR optr;
X    char *str;
X{
X    char *s, *t, buf[ 100 ];
X    int i, sidx, state = 0;
X    int done = 0;
X
X    ZapOptions( optr );
X    s = buf;
X    *buf = 0;
X    sidx = -1;
X
X    /* Start past the 'options=' part */
X    for( t = str; !done; ++t )
X    {
X    if( state == 0 && isspace( *t ) )
X        continue;
X
X    /* If at end remember so... */
X    if( !*t )
X        done = 1;
X
X    /* If looking for an option value */
X    if( state == 0 )
X    {
X        /* If found string value... */
X        if( *t == ':' )
X        {
X        *s = 0;
X        state = 1;
X        sidx = -1;
X
X        /* Look for the particular named option */
X        for( i = 0; optr[i].name; ++i )
X        {
X            if( stricmp( optr[i].name, buf ) == 0 )
X            {
X            sidx = i;
X            break;
X            }
X        }
X
X        /* Set buffer pointer */
X        *(s = buf) = 0;
X
X        if( sidx == -1 )
X        {
X            errmsg( FLASH, "Invalid option name %s", buf );
X            return;
X        }
X        if( !optr[i].optstr )
X        {
X            errmsg( FLASH, "%s is not a string option", buf );
X            return;
X        }
X        continue;
X        }
X    }
X
X    /* If at end of string or comma and we have some text... */
X    if( !*t || *t == ',' && *buf )
X    {
X        /* Mark end */
X        *s = 0;
X
X        /* If have collected string option value... */
X        if( sidx != -1 )
X        {
X        /* Free old string */
X        if( optr[sidx].optstr )
X        {
X            if( *optr[sidx].optstr )
X            free( optr[sidx].optstr );
X        }
X
X        /* Store new string */
X        if( *buf )
X            optr[sidx].optstr = strdup( buf );
X        else
X            optr[sidx].optstr = "";
X        sidx = -1;
X        }
X        else
X        {
X        /* Look for boolean option */
X        for( i = 0; optr[i].name; ++i )
X        {
X            if( *buf == '!' )
X            {
X            if( stricmp( optr[i].name, buf + 1 ) == 0 )
X                break;
X            }
X            else
X            {
X            if( stricmp( optr[i].name, buf ) == 0 )
X                break;
X            }
X        }
X
X        if( optr[i].name )
X        {
X            optr[i].optval = *buf != '!';
X        }
X        else
X        {
X            errmsg( FLASH, "Unrecognized option %s", buf );
X            return;
X        }
X        }
X        *(s = buf) = 0;
X        state = 0;
X    }
X    else
X    {
X        if( *t == ',' )
X        *(s = buf) = 0;
X        else
X        *s++ = *t;
X    }
X    }
X}
X
X/* !CLI */
X
X/*
X *  Set the GAMES OPTIONS tooltypes to the data in the Options windows
X *  gadgetry.
X */
Xvoid SetOptions( optr, gptr )
X    register OPTR optr;
X    register GPTR gptr;
X{
X    PutOptions( optr );
X    SetToolLine( gptr, "OPTIONS", options[ OPTIONS_IDX ] );
X    UpdateGameIcon( gptr );
X}
X
Xvoid
XUpdateGameIcon( gptr )
X    register GPTR gptr;
X{
X    register long lock;
X
X    if( lock = Lock( gptr->dname, ACCESS_READ ) )
X    {
X    /* Write out the DiskObject */
X
X    WriteDObj( gptr, lock );
X    UnLock( lock );
X    }
X    else
X    {
X    errmsg( FLASH, "Can't change directory to %s", gptr->dname );
X    }
X}
X
X#endif  /* CLI */
X
Xchar *ToolsEntry( gptr, name )
X    GPTR gptr;
X    char *name;
X{
X    char *str;
X
X    if( ! ( str = FindToolType( (char **) gptr->dobj->do_ToolTypes, name ) ) )
X    str = "";
X
X    return( str );
X}
X
X/* Reallocate the toolstype information into dynamic memory so that some
X * parts of it can be easily changed, but we can still do "FreeDiskObject"
X * later to clean up whatever "GetDiskObject" allocated.
X */
Xvoid ReallocTools( gptr, add )
X    GPTR gptr;
X    int add;
X{
X    int i, cnt;
X    char **sp, **tp;
X
X    for( cnt = 0, tp = gptr->dobj->do_ToolTypes; tp && *tp ; ++tp )
X    ++cnt;
X
X    if( !tp )
X    {
X    /* If no tooltypes array, fudge something to start with */
X    if( sp = xmalloc( 2 * sizeof( char * ) ) )
X    {
X        sp[0] = strdup("HACKDIR=NetHack:");
X        sp[1] = NULL;
X    }
X    }
X    else if( sp = xmalloc( (cnt+1+add) * sizeof( char * ) ) )
X    {
X    for( i = 0, tp = gptr->dobj->do_ToolTypes;
X            tp && *tp && i < cnt; ++tp )
X    {
X        sp[i++] = strdup( *tp );
X    }
X
X    sp[i] = NULL;
X    }
X    gptr->otools = gptr->dobj->do_ToolTypes;
X    gptr->dobj->do_ToolTypes = sp;
X    gptr->toolcnt = cnt + 1;
X    gptr->talloc = 1;
X}
X
Xvoid FreeTools( gptr )
X    GPTR gptr;
X{
X    int i;
X    char **sp;
X
X    if( !gptr->talloc )
X    return;
X
X    for( i = 0, sp = gptr->dobj->do_ToolTypes; sp[i]; ++i )
X    {
X    free( sp[ i ] );
X    sp[ i ] = NULL;
X    }
X    free( sp );
X    gptr->dobj->do_ToolTypes = gptr->otools;
X    gptr->talloc = 0;
X}
X
Xvoid SetToolLine( gptr, name, value )
X    GPTR gptr;
X    char *name, *value;
X{
X    char **sp, **osp;
X    int i, len;
X
X    /* Realloc ToolTypes to be in memory we know how to manage */
X
X    if( gptr->talloc == 0 )
X    ReallocTools( gptr, 0 );
X
X    sp = gptr->dobj->do_ToolTypes;
X    len = strlen( name );
X
X    /* Find any previous definition */
X    for( i = 0; sp[i] && i < gptr->toolcnt - 1; ++i )
X    {
X    if( strnicmp( name, sp[i], len ) == 0 && sp[i][len] == '=' )
X        break;
X    }
X
X    /* Free up the space, or allocate new space if not there */
X    if( sp[ i ] )
X    free( sp[ i ] );
X    else
X    {
X    /* Check for need to realloc */
X
X    if( i >= gptr->toolcnt - 1 )
X    {
X        int j=i;
X        osp = sp;
X        sp = xmalloc( ( i + 2 ) * sizeof( char * ) );
X        gptr->toolcnt = i + 2;
X        sp[ i + 1 ] = NULL;
X        while( j >= 0 )
X        {
X        sp[ j ] = osp[ j ];
X        --j;
X        }
X        free( osp );
X        /* i = gptr->toolcnt - 1; */
X        gptr->dobj->do_ToolTypes = sp;
X    }
X    else
X    {
X        sp[ i + 1 ] = NULL;
X    }
X    }
X
X    /* Set the string */
X
X    if( sp[ i ] = xmalloc( strlen (value) + strlen( name ) + 2 ) )
X    sprintf( sp[i], "%s=%s", name, value );
X    else
X    {
X    sp[ i ] = NULL;     /* redundant */
X    errmsg( FLASH, "Could not allocate string for value" );
X    }
X}
X
Xvoid WriteDObj( gptr, lock )
X    register GPTR gptr;
X    long lock;
X{
X    register long odir;
X    long flag, act;
X
X    /* Don't write gadget out as selected */
X
X    flag = gptr->dobj->do_Gadget.Flags;
X    act = gptr->dobj->do_Gadget.Activation;
X    gptr->dobj->do_Gadget.Flags = gptr->oflag;
X    gptr->dobj->do_Gadget.Activation = gptr->oact;
X    odir = CurrentDir( lock );
X
X    if( PutDiskObject( gptr->name, gptr->dobj ) == 0 )
X    errmsg( FLASH, "Could not write disk object values" );
X
X    gptr->dobj->do_Gadget.Flags = flag;
X    gptr->dobj->do_Gadget.Activation = act;
X
X    if( odir )
X    (void) CurrentDir( odir );
X}
X
Xchar *Strdup( str )
X    char *str;
X{
X    char *t;
X
X    if( t = AllocMem( strlen( str ) + 1, MEMF_PUBLIC ) )
X    strcpy( t, str );
X    return( t );
X}
X
X#ifdef CLI
X
Xchar *
Xeos(s)
X    char *s;
X{
X    while(*s)s++;
X    return s;
X}
X
X/* CLI */
X
Xvoid
Xcondaddslash(s)
X    char *s;
X{
X    s=eos(s);
X    switch(s[-1]){
X    case ':':
X    case '/':
X    break;
X    default:
X    s[0]='/';
X    s[1]='\0';
X    break;
X    }
X    return;
X}
X
X/* CLI */
X
X#if 0
X/* for debug only */
X#define BP __builtin_printf
Xdumptools(sp,i)
X    char **sp;
X    int i;
X{
X    int x;
X    BP("Dumptools: cnt=%d\n",i);
X    for(x=0;sp[x];x++)
X    BP("%d: '%s'\n",x,sp[x]);
X}
X#endif
X
X#else   /* CLI */
X
Xvoid ClearDelGames()
X{
X    register GPTR gptr, pgptr = NULL;
X
X    for( gptr = gamehead; gptr; )
X    {
X    /* Skip New Game */
X
X    if( gptr->fname == NULL )
X    {
X        gptr = gptr->next;
X        continue;
X    }
X
X    /* If gone, then remove structures */
X
X    if( access( GameName( gptr, NULL ), 0 ) == -1 )
X    {
X        if( pgptr )
X        pgptr->next = gptr->next;
X        else
X        gamehead = gptr->next;
X
X        FreeGITEM( gptr );
X        gptr = pgptr ? pgptr : gamehead;
X    }
X    else
X    {
X        pgptr = gptr;
X        gptr = gptr->next;
X    }
X    }
X}
X
X/* !CLI */
X
Xstruct TagItem tags[] =
X{
X    TAG_DONE, 0l,
X};
X
Xstruct Window *
XMyOpenWindow( nw )
X#ifdef  INTUI_NEW_LOOK
X    struct ExtNewWindow *nw;
X#else
X    struct NewWindow *nw;
X#endif
X{
X#ifdef  INTUI_NEW_LOOK
X    /*nw->Extension = tags;
X    nw->Flags = WFLG_NW_EXTENDED;*/
X#endif
X#undef  NewWindow
X    return( OpenWindow( (struct NewWindow *) nw ) );
X}
X
X#endif  /* CLI */
X
Xvoid
Xdiskobj_filter( dobj )
X    struct DiskObject *dobj;
X{
X    char **ta=dobj->do_ToolTypes;
X    int x;
X
X    /* if nothing there, just return. */
X    if( !ta )
X        return;
X
X#ifdef CLI
X    /* kill everything except INTERNALCLI */
X
X    for(x=0;ta[x];x++){
X    if(!strncmp(ta[x],"INTERNALCLI=",12)){
X        ta[0]=ta[x];
X        ta[1]=0;
X        return;
X    }
X    }
X    ta[0]=0;
X#else
X    /* kill INTERNALCLI */
X    for(x=0;ta[x];x++){
X        int offset=0;
X    while(ta[x+offset] && !strncmp(ta[x+offset],"INTERNALCLI=",12)){
X        offset++;
X        }
X        ta[x]=ta[x+offset];
X    }
X#endif
X}
END_OF_FILE
if test 38406 -ne `wc -c <'sys/amiga/wbcli.c'`; then
    echo shar: \"'sys/amiga/wbcli.c'\" unpacked with wrong size!
fi
# end of 'sys/amiga/wbcli.c'
fi
if test -f 'sys/msdos/trampoli.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'sys/msdos/trampoli.c'\"
else
echo shar: Extracting \"'sys/msdos/trampoli.c'\" \(15116 characters\)
sed "s/^X//" >'sys/msdos/trampoli.c' <<'END_OF_FILE'
X/*    SCCS Id: @(#)trampoli.c     3.1    93/01/18      */
X/* Copyright (c) 1989 - 1993 by Norm Meluch and Stephen Spackman  */
X/* NetHack may be freely redistributed.  See license for details. */
X
X#include "hack.h"
X
X/****************************************************************************/
X/*                                        */
X/*    This file contains a series of definitions of "one liner"        */
X/*    functions corresponding to *all* functions that NetHack calls        */
X/*    via pointers.                                */
X/*         IF ANY CALLS TO FUNCTIONS VIA POINTERS ARE ADDED            */
X/*         TO THE CODE, AN ENTRY FOR THE FUNCTION CALLED MUST            */
X/*         BE ADDED TO THIS FILE AND TO TRAMPOLI.H.                */
X/*    This mess is necessary for the Microsoft Compiler implementation    */
X/*    of overlaid code (v5.1 - 6.0ax).                    */
X/*                                        */
X/*    The original function (eg foo) has been #defined to be foo_        */
X/*    via double inclusion of trampoli.h in hack.h, and            */
X/*    now the definition of foo is placed in this file calling foo        */
X/*    directly.  This module is _never_ placed in an overlay so        */
X/*    calls via pointers to these functions will not cause difficulties.  */
X/*                                        */
X/*    This leads to what could be called a "trampoline" effect, and        */
X/*    hence the silly name for these files. :-)                */
X/*                                        */
X/****************************************************************************/
X
X#ifdef OVERLAY
X
X/* ### apply.c ### */
X#undef dig
X#undef doapply
X#undef dojump
X#undef dorub
X
Xint dig()     { return dig_();     }
Xint doapply() { return doapply_(); }
Xint dojump()  { return dojump_();  }
Xint dorub()   { return dorub_();   }
X
X
X/* ### cmd.c ### */
X#undef doextcmd
X#undef doextlist
X#undef doprev_message
X
X#ifdef POLYSELF
X#undef domonability
X#endif /* POLYSELF */
X
X#ifdef EXPLORE_MODE
X#undef enter_explore_mode
X
Xint enter_explore_mode() { return enter_explore_mode_(); }
X#endif
X
X#undef timed_occupation
X
X#if defined(WIZARD) || defined(EXPLORE_MODE)
X#undef wiz_attributes
X#endif
X
X#ifdef WIZARD
X#undef wiz_detect
X#undef wiz_genesis
X#undef wiz_identify
X#undef wiz_level_tele
X#undef wiz_map
X#undef wiz_where
X#undef wiz_wish
X#endif
X
Xint doextcmd()         { return doextcmd_();         }
Xint doextlist()        { return doextlist_();        }
Xint doprev_message()   { return doprev_message_();   }
X
X#ifdef POLYSELF
Xint domonability()     { return domonability_();     }
X#endif /* POLYSELF */
X
Xint timed_occupation() { return timed_occupation_(); }
X
X#if defined(WIZARD) || defined(EXPLORE_MODE)
Xint wiz_attributes()   { return wiz_attributes_();   }
X#endif
X
X#ifdef WIZARD
Xint wiz_detect()       { return wiz_detect_();       }
Xint wiz_genesis()      { return wiz_genesis_();      }
Xint wiz_identify()     { return wiz_identify_();     }
Xint wiz_level_tele()   { return wiz_level_tele_();   }
Xint wiz_map()          { return wiz_map_();          }
Xint wiz_where()        { return wiz_where_();        }
Xint wiz_wish()         { return wiz_wish_();         }
X#endif
X
X
X/* ### do.c ### */
X#undef doddrop
X#undef dodown
X#undef dodrop
X#undef donull
X#undef doup
X#undef dowipe
X#undef drop
X#undef wipeoff
X
Xint doddrop()             { return doddrop_(); }
Xint dodown()              { return dodown_();  }
Xint dodrop()              { return dodrop_();  }
Xint donull()              { return donull_();  }
Xint doup()                { return doup_();    }
Xint dowipe()              { return dowipe_();  }
Xint drop(obj)
Xregister struct obj *obj; { return drop_(obj); }
Xint wipeoff()             { return wipeoff_(); }
X
X
X/* ### do_name.c ### */
X#undef ddocall
X#undef do_mname
X
Xint ddocall()  { return ddocall_();  }
Xint do_mname() { return do_mname_(); }
X
X
X/* ### do_wear.c ### */
X#undef Armor_off
X#undef Boots_off
X#undef Gloves_off
X#undef Helmet_off
X#undef Armor_on
X#undef Boots_on
X#undef Gloves_on
X#undef Helmet_on
X#undef doddoremarm
X#undef doputon
X#undef doremring
X#undef dotakeoff
X#undef dowear
X#undef select_off
X#undef take_off
X
Xint Armor_off()   { return Armor_off_();   }
Xint Boots_off()   { return Boots_off_();   }
Xint Gloves_off()  { return Gloves_off_();  }
Xint Helmet_off()  { return Helmet_off_();  }
Xint Armor_on()    { return Armor_on_();    }
Xint Boots_on()    { return Boots_on_();    }
Xint Gloves_on()   { return Gloves_on_();   }
Xint Helmet_on()   { return Helmet_on_();   }
Xint doddoremarm() { return doddoremarm_(); }
Xint doputon()     { return doputon_();     }
Xint doremring()   { return doremring_();   }
Xint dotakeoff()   { return dotakeoff_();   }
Xint dowear()      { return dowear_();      }
Xint select_off(otmp) struct obj *otmp; { return select_off_(otmp); }
Xint take_off()    { return take_off_();    }
X
X
X/* ### dogmove ### */
X#undef wantdoor
X
Xvoid wantdoor(x, y, dummy)
Xint x, y; genericptr_t dummy; { return wantdoor_(x, y, dummy); }
X
X
X/* ### dokick.c ### */
X#undef dokick
X
Xint dokick() { return dokick_(); }
X
X
X/* ### dothrow.c ### */
X#undef dothrow
X
Xint dothrow() { return dothrow_(); }
X
X
X/* ### eat.c ### */
X#undef Hear_again
X#undef eatmdone
X#undef doeat
X#undef eatfood
X#undef opentin
X#undef unfaint
X
Xint Hear_again()  { return Hear_again_(); }
Xint eatmdone()    { return eatmdone_();   }
Xint doeat()       { return doeat_();      }
Xint eatfood()     { return eatfood_();    }
Xint opentin()     { return opentin_();    }
Xint unfaint()     { return unfaint_();    }
X
X
X/* ### end.c ### */
X#undef done1
X#undef done2
X#undef hangup
X#undef done_intr
X
X#if defined(UNIX) || defined(VMS)
X#undef done_hangup
X#endif /* UNIX || VMS */
X
Xint done1()     { return done1_();     }
Xint done2()     { return done2_();     }
Xint hangup()    { return hangup_();    }
Xint done_intr() { return done_intr_(); }
X
X#if defined(UNIX) || defined(VMS)
Xint done_hangup() { return done_hangup_(); }
X#endif /* UNIX || VMS */
X
X
X/* ### engrave.c ### */
X#undef doengrave
X
Xint doengrave() { return doengrave_(); }
X
X
X/* ### fountain.c ### */
X#undef gush
X
Xvoid gush(x, y, poolcnt)
Xint x, y; genericptr_t poolcnt; { return gush_(x, y, poolcnt); }
X
X
X/* ### hack.c ### */
X#undef dopickup
X#undef identify
X
Xint dopickup() { return dopickup_(); }
Xint identify(otmp) struct obj *otmp; { return identify_(otmp); }
X
X
X/* ### invent.c ### */
X#undef ckunpaid
X#undef ddoinv
X#undef dolook
X#undef dopramulet
X#undef doprarm
X#undef doprgold
X#undef doprring
X#undef doprtool
X#undef doprwep
X#undef dotypeinv
X#undef doorganize
X
Xint ckunpaid(obj) struct obj *obj; { return ckunpaid_(obj); }
Xint ddoinv()     { return ddoinv_();     }
Xint dolook()     { return dolook_();     }
Xint dopramulet() { return dopramulet_(); }
Xint doprarm()    { return doprarm_();    }
Xint doprgold()   { return doprgold_();   }
Xint doprring()   { return doprring_();   }
Xint doprtool()   { return doprtool_();   }
Xint doprwep()    { return doprwep_();    }
Xint dotypeinv()  { return dotypeinv_();  }
Xint doorganize() { return doorganize_(); }
X
X
X/* ### ioctl.c ### */
X#ifdef UNIX
X# ifdef SUSPEND
X#undef dosuspend
X
Xint dosuspend() { return dosuspend_(); }
X# endif /* SUSPEND */
X#endif /* UNIX */
X
X
X/* ### lock.c ### */
X#undef doclose
X#undef doforce
X#undef doopen
X#undef forcelock
X#undef picklock
X
Xint doclose()   { return doclose_();   }
Xint doforce()   { return doforce_();   }
Xint doopen()    { return doopen_();    }
Xint forcelock() { return forcelock_(); }
Xint picklock()  { return picklock_();  }
X
X
X/* ### mklev.c ### */
X#undef do_comp
X
Xint do_comp(vx, vy) genericptr_t vx, vy;  { return comp_(vx, vy); }
X
X
X/* ### mondata.c ### */
X/* canseemon() is only called by a macro e_boolean.  If e_boolean ever does
X   become a function, this may need to return. */
X
X/* #undef canseemon */
X
X/* boolean canseemon(x) struct monst *x; { return canseemon_(x); } */
X
X
X/* ### muse.c ### */
X#undef mbhitm
X
Xint mbhitm(mtmp, otmp) struct monst *mtmp; struct obj *otmp;
X    { return mbhitm_(mtmp, otmp); }
X
X
X/* ### o_init.c ### */
X#undef dodiscovered
X
Xint dodiscovered() { return dodiscovered_(); }
X
X
X/* ### objnam.c ### */
X#undef doname
X#undef xname
X
Xchar *doname(obj) struct obj *obj; { return doname_(obj); }
Xchar *xname(obj)  struct obj *obj; { return xname_(obj); }
X
X
X/* ### options.c ### */
X#undef doset
X#undef dotogglepickup
X
Xint doset()          { return doset_();         }
Xint dotogglepickup() { return dotogglepickup_(); }
X
X
X/* ### pager.c ### */
X#undef dohelp
X#undef dohistory
X#undef dowhatdoes
X#undef dowhatis
X#undef doquickwhatis
X
Xint dohelp()        { return dohelp_();        }
Xint dohistory()     { return dohistory_();     }
Xint dowhatdoes()    { return dowhatdoes_();    }
Xint dowhatis()      { return dowhatis_();      }
Xint doquickwhatis() { return doquickwhatis_(); }
X
X
X/* ### pcsys.c ### */
X#ifdef SHELL
X#undef dosh
X
Xint dosh()          { return dosh_();          }
X#endif /* SHELL */
X
X
X/* ### pickup.c ### */
X#undef ck_bag
X#undef doloot
X#undef in_container
X#undef out_container
X
Xint ck_bag(obj) struct obj *obj; { return ck_bag_(obj);  }
Xint doloot() { return doloot_(); }
Xint in_container(obj)  struct obj *obj; { return in_container_(obj); }
Xint out_container(obj) struct obj *obj; { return out_container_(obj); }
X
X
X/* ### potion.c ### */
X#undef dodrink
X#undef dodip
X
Xint dodrink() { return dodrink_(); }
Xint dodip()   { return dodip_();   }
X
X
X/* ### pray.c ### */
X#undef doturn
X#undef dopray
X#undef prayer_done
X#undef dosacrifice
X
Xint doturn()      { return doturn_();      }
Xint dopray()      { return dopray_();      }
Xint prayer_done() { return prayer_done_(); }
Xint dosacrifice() { return dosacrifice_(); }
X
X
X/* ### print.c ### */
X#undef doredraw
X
Xint doredraw()    { return doredraw_(); }
X
X
X/* ### read.c ### */
X#undef doread
X#undef set_lit
X
Xint doread()            { return doread_(); }
Xvoid set_lit(x, y, val)
Xint x, y; genericptr_t val; { return set_lit_(x, y, val); }
X
X
X/* ### save.c ### */
X#undef dosave
X
Xint dosave() { return dosave_(); }
X
X
X/* ### search.c ### */
X#undef findone
X#undef openone
X#undef doidtrap
X#undef dosearch
X
Xvoid findone(zx, zy, num)
Xint zx, zy; genericptr_t num; { return findone_(zx, zy, num); }
Xvoid openone(zx, zy, num)
Xint zx, zy; genericptr_t num; { return openone_(zx, zy, num); }
Xint doidtrap()              { return doidtrap_(); }
Xint dosearch()              { return dosearch_(); }
X
X
X/* ### shk.c ### */
X#undef dopay
X
Xint dopay() { return dopay_(); }
X
X
X/* ### sit.c ### */
X#undef dosit
X
Xint dosit() { return dosit_(); }
X
X
X/* ### sounds.c ### */
X#undef dotalk
X
Xint dotalk() { return dotalk_(); }
X
X
X/* ### spell.c ### */
X#undef learn
X#undef docast
X#undef dovspell
X
Xint learn() { return learn_(); }
Xint docast()   { return docast_();   }
Xint dovspell() { return dovspell_(); }
X
X
X/* ### steal.c ### */
X#undef stealarm
X
Xint stealarm() { return stealarm_(); }
X
X
X/* ### trap.c ### */
X#undef dotele
X#undef dountrap
X#undef float_down
X
Xint dotele()     { return dotele_();     }
Xint dountrap()   { return dountrap_();   }
Xint float_down() { return float_down_(); }
X
X
X/* ### version.c ### */
X#undef doversion
X#undef doextversion
X
Xint doversion()    { return doversion_();    }
Xint doextversion() { return doextversion_(); }
X
X
X/* ### wield.c ### */
X#undef dowield
X
Xint dowield() { return dowield_(); }
X
X
X/* ### zap.c ### */
X#undef bhitm
X#undef bhito
X#undef dozap
X
Xint bhitm(mtmp, otmp) struct monst *mtmp; struct obj *otmp;
X    { return bhitm_(mtmp, otmp); }
Xint bhito(obj, otmp) struct obj *obj, *otmp; { return bhito_(obj,  otmp); }
Xint dozap() { return dozap_(); }
X
X/*
X * Window Implementation Specific Functions.
X */
X
X
X/* ### getline.c ### */
X#undef tty_getlin
X#ifdef COM_COMPL
X#undef tty_get_ext_cmd
X
Xvoid tty_get_ext_cmd(bufp)
X  char *bufp;            { tty_get_ext_cmd_(bufp);    }
X#endif /* COM_COMPL */
Xvoid tty_getlin(query,bufp)
X  const char *query; char *bufp;{ tty_getlin_(query,bufp);    }
X
X
X/* ### termcap.c ### */
X#undef tty_nhbell
X#undef tty_number_pad
X#undef tty_delay_output
X#undef tty_start_screen
X#undef tty_end_screen
X
Xvoid tty_nhbell()        { tty_nhbell_();         }
Xvoid tty_number_pad(state)
X  int state;            { tty_number_pad_(state);    }
Xvoid tty_delay_output()        { tty_delay_output_();         }
X/* other defs that really should go away (they're tty specific) */
Xvoid tty_start_screen()        { tty_start_screen_();         }
Xvoid tty_end_screen()        { tty_end_screen_();         }
X
X
X/* ### topl.c ### */
X#undef tty_doprev_message
X#undef tty_yn_function
X
Xint tty_doprev_message()    { tty_doprev_message_();     }
Xchar tty_yn_function(query,resp,def)
X  const char *query, *resp; char def;
X                { tty_yn_function_(query,resp,def); }
X
X
X/* ### wintty.c ### */
X#undef tty_init_nhwindows
X#undef tty_player_selection
X#undef tty_askname
X#undef tty_get_nh_event
X#undef tty_exit_nhwindows
X#undef tty_suspend_nhwindows
X#undef tty_resume_nhwindows
X#undef tty_create_nhwindow
X#undef tty_clear_nhwindow
X#undef tty_display_nhwindow
X#undef tty_destroy_nhwindow
X#undef tty_curs
X#undef tty_putstr
X#undef tty_display_file
X#undef tty_start_menu
X#undef tty_add_menu
X#undef tty_end_menu
X#undef tty_select_menu
X#undef tty_update_inventory
X#undef tty_mark_synch
X#undef tty_wait_synch
X#ifdef CLIPPING
X#undef tty_cliparound
X#endif
X#undef tty_print_glyph
X#undef tty_raw_print
X#undef tty_raw_print_bold
X#undef tty_nhgetch
X#undef tty_nh_poskey
X
Xvoid tty_init_nhwindows()    { tty_init_nhwindows_();    }
Xvoid tty_player_selection()    { tty_player_selection_();     }
Xvoid tty_askname()        { tty_askname_();         }
Xvoid tty_get_nh_event()        { tty_get_nh_event_();         }
Xvoid tty_exit_nhwindows(str)
X  const char *str;        { tty_exit_nhwindows_(str);    }
Xvoid tty_suspend_nhwindows(str)
X  const char *str;        { tty_suspend_nhwindows_(str);    }
Xvoid tty_resume_nhwindows()    { tty_resume_nhwindows_();     }
Xwinid tty_create_nhwindow(type)
X  int type;            { tty_create_nhwindow_(type);    }
Xvoid tty_clear_nhwindow(window)
X  winid window;            { tty_clear_nhwindow_(window);    }
Xvoid tty_display_nhwindow(window, blocking)
X  winid window; boolean blocking;
X                { tty_display_nhwindow_(window,blocking); }
Xvoid tty_destroy_nhwindow(window)
X  winid window;            { tty_destroy_nhwindow_(window); }
Xvoid tty_curs(window,x,y)
X  winid window; int x,y;    { tty_curs_(window,x,y);    }
Xvoid tty_putstr(window,attr,str)
X  winid window; int attr; const char *str;
X                { tty_putstr_(window,attr,str); }
Xvoid tty_display_file(fname, complain)
X  const char *fname; boolean complain;
X                { tty_display_file_(fname,complain); }
Xvoid tty_start_menu(window)
X  winid window;            { tty_start_menu_(window);    }
Xvoid tty_add_menu(window,ch,attr,str)
X  winid window; char ch; int attr; const char *str;
X                { tty_add_menu_(window,ch,attr,str); }
Xvoid tty_end_menu(window,ch,str,morestr)
X  winid window; char ch; const char *str, *morestr;
X                { tty_end_menu_(window,ch,str,morestr);    }
Xchar tty_select_menu(window)
X  winid window;            { tty_select_menu_(window);    }
Xvoid tty_update_inventory()    { tty_update_inventory_();     }
Xvoid tty_mark_synch()        { tty_mark_synch_();         }
Xvoid tty_wait_synch()        { tty_wait_synch_();         }
X#ifdef CLIPPING
Xvoid tty_cliparound(x,y)
X  int x,y;            { tty_cliparound_(x,y);        }
X#endif
Xvoid tty_print_glyph(window,x,y,glyph)
X  winid window; xchar x,y; int glyph;
X                { tty_print_glyph_(window,x,y,glyph); }
Xvoid tty_raw_print(str)
X  const char *str;        { tty_raw_print_(str);         }
Xvoid tty_raw_print_bold(str)
X  const char *str;        { tty_raw_print_bold_(str);     }
Xint tty_nhgetch()        { tty_nhgetch_();         }
Xint tty_nh_poskey(x,y,pos)
X  int *x,*y,*pos;        { tty_nh_poskey_(x,y,pos);    }
X
X#endif /* OVERLAY */
END_OF_FILE
if test 15116 -ne `wc -c <'sys/msdos/trampoli.c'`; then
    echo shar: \"'sys/msdos/trampoli.c'\" unpacked with wrong size!
fi
# end of 'sys/msdos/trampoli.c'
fi
echo shar: End of archive 38 \(of 108\).
cp /dev/null ark38isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 \
21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 \
41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 \
61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 \
81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 \
101 102 103 104 105 106 107 108 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 108 archives.
    echo "Now execute 'rebuild.sh'"
    rm -f ark10[0-8]isdone ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0