Path: utzoo!hoptoad!amdcad!decwrl!labrea!rutgers!mailrus!tut.cis.ohio-state.edu!cs.utexas.edu!uhnix1!sugar!amiga-sources@sugar.uu.net
From: amiga-sources@sugar.uu.net (alt.sources.amiga)
Newsgroups: alt.sources.amiga
Subject: meter: memory meter -- Howard Hull
Message-ID: <2824@sugar.uu.net>
Date: 15 Oct 88 13:13:14 GMT
Sender: peter@sugar.uu.net
Organization: Hackercorp
Lines: 1486
Approved: amiga-sources@sugar.uu.net (alt.sources.amiga)

Archive: uunet!~uucp/amiga-sources/meter.sh.Z

:
#! /bin/sh
# This is a shell archive, created on Sugar Land Unix (..!uunet!sugar)
# (bbs: 713-438-5018) by peter (Peter da Silva) on Sat Oct 15 08:05:28 1988
# Remove anything before the "#! /bin/sh" line, then unpack it by saving
# it into a file and typing "sh file".  If you do not have sh, you need 
# unshar, a dearchiving program which is widely available.  In the absolute
# wost case, you can crack the files out by hand.
# If the archive is complete, you will see the message "End of archive."
# at the end.
# This archive contains the following files...
# 'mm.doc'
# 'mm.h'
# 'mm3.c'
# 'mminit3.c'
# To extract them, run the following through /bin/sh
echo x - mm.doc
sed 's/^X//' > mm.doc << '//END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X/*
X *   MemMometer - program hacked from Rokicki's WFrags more or less...
X *   (in fact, a heck of a lot) in the style of Peter DaSilva's "Gauge."
X *   The program opens a narrow window with the same dimensions as the
X *   disk capacity gadget found in the top-level workbench window for
X *   a floppy volume.  The sizing gadget is like the one in Gauge; to
X *   resize the window, just click the left mouse button over the "E".
X *   My bin copy of Gauge broke when I put a Michigan Insider in my A1000.
X *   I did not have source for the Gauge program, so I conjured this one.
X *
X *   Note that in the display there's one memmometer for Chip (left-hand
X *   column ), another for Slow Fast mem (center column) and another for
X *   Fast mem (right-hand column ).  These memmometers can be turned on or
X *   off as desired by selecting "NONE" or the various items in the Size
X *   menus.  Parts of several FD programs have been used to make MemMometer.
X *   Menus, for instance, are a la VT100 (Wecker, et al).  As with the
X *   VT100 program, MemMometer has preset variables.  However, the program
X *   does not presently contain a script file reader or an AREXX interface
X *   with which to automatically set the variables.  Maybe this will
X *   happen in a future rev (volunteers?).
X *
X *   FRAGS mode:
X *   The 'mometers display a frequently-updated window indicating the extent
X *   of memory fragmentation and free memory, thus showing the sizes of the
X *   largest available chunks.  Black is unallocated, blue is partially
X *   framented, red-orange is fully allocated.  It takes a while after
X *   startup to settle out and display the upper fast mem, so be patient...
X *   It's useful for finding out why those large programs won't load.  Also
X *   useful during development to see what impact your application is having
X *   on memory fragmentation.
X *
X *   WARPS mode:
X *   The 'mometer displays any change that it sees in memory, BUT this mode
X *   only works sensibly when JUST ONE memory size selection is active (set
X *   others to "NONE").  Black areas are unchanged sections of memory, blue
X *   areas are sections with zeroed long words in them, and red-orange areas
X *   are sections containing recently changed long words.  Given that you
X *   may have two areas of memory active in the compare, though, it is
X *   possible to set it up (by careful planning w.r.t. the ways of AmigaDOS
X *   memory management) so that something double buffered between CHIP and
X *   RAM can be compared using this "mis-feature."  If you can load an area,
X *   say, at a selectable boundary in RAM and its counterpart at the 256K
X *   boundary in CHIP, (or similarly juggled arrangements in slow-fast and
X *   fast RAM) you can use WARPS to judge the extent of differences between
X *   two or perhaps even three similar fields.
X *
X *   To run, simply type
X *
X *      run MM3  or  click on the icon.
X *
X *   Then open the menu item selections and set them for your configuration.
X *   Frags mode, 512K of CHIP @0, 0.5Meg of SF @C00000, and 2MB FAST mem are
X *   the defaults.  Timing (Freq) is rather ragged, sorry about that...
X *
X *   That's all!  Enjoy this program.  Forget about the bugs.  :-)  mm3 uses
X *   Amy's Forbid, Permit, and the notorious v1.2 Delay function - so you'll
X *   probably get a track 40 error some day when you expect it least (I did).
X *   It's good discipline for remembering to make backups... ::--))
X *
X *   The source to mm3 is freely distributable; the copy of Rokiki's WFrags
X *   I was working with had no copyright or distribution restrictions, and
X *   Wecker's VT100 is known to be in the public domain.  I add no further
X *   restrictions to, nor accept any responsibilities for the use of the
X *   codes herein, which are recommended for entertainment purposes only.
X *   So get out your Manx 3.6a compiler and fix the bugs yourself, then
X *   compile and link as described in the makefile.
X *                                                              Good Luck.
X *
X *   Howard Hull  (The C Barbarian)*     hull@hao.ucar.edu
X *
X *   			*( A matter of primitive language, not piracy...)
X */
//END_OF_FILE
echo x - mm.h
sed 's/^X//' > mm.h << '//END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X#include <intuition/intuition.h>
X#include <intuition/intuitionbase.h>
X#include <graphics/gfx.h>
X#include <graphics/gfxbase.h>
X#include <exec/exec.h>
X#include <exec/execbase.h>
X#include <functions.h>
X
Xextern struct IntuitionBase *IntuitionBase ;
Xextern struct Window *window ;
Xextern struct MsgPort *myport ;
X
//END_OF_FILE
echo x - mm3.c
sed 's/^X//' > mm3.c << '//END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X#include "mm.h"
X
X#define REDP 3L        /* workbench pen colors for Draw and RectFill */
X#define BLKP 2L
X#define WHTP 1L
X#define BLUP 0L
X
X#define SOK        0x001f     /* memory allocation control masks */
X#define S1         0x0001
X#define S2         0x0002
X#define S4         0x0004
X#define S8         0x0008
X#define SA         0x0010
X#define C1         0xfffe
X#define C2         0xfffd
X#define C4         0xfffb
X#define C8         0xfff7
X#define CA         0xffef
X
X#define EXTENSION  16L       /* allocation request increment */
X
X#define EVENMASK 0x7ffffffe           /* used to prevent odd address traps */
X#define CLIHEIGHT 200L                             /* window scaling stuff */
X#define SIZEGAD 9L
X#define DRAGBAR 10L
X#define BORDER 2L
X#define WINW 16L                                   /* initial window width */
X#define WINH (long)(CLIHEIGHT - SIZEGAD - DRAGBAR)   /* initial win height */
X#define MINH 81L                              /* shortest allowable window */
X#define MAXH 576L                              /* longest allowable window */
X#define BART 1L                               /* title bar F text location */
X#define BARH (long)(WINH - SIZEGAD - DRAGBAR)                /* bar height */
X#define BARS (long)(BARH + 1)        /* number of memory items to allocate */
X#define BARB (long)(BARH + DRAGBAR - 1)        /* bottom of mercury column */
X#define BARE (long)(BARB + BORDER)              /* bar end E text position */
X#define BARW (long)(((WINW - (2 * BORDER)) / 3) - 1)  /* 3 memfragmometers */
X#define LEFT BORDER                   /* SLOW : since we're syncopated, we */
X#define MIDDLE (LEFT + BARW + 1)      /* SLOW-FAST : do it going from bar  */
X#define RIGHT (MIDDLE + BARW + 1)     /* FAST :to bar at an irregular pace */
X#define RTEXT - 4L        /* offset for three char E/F text from left edge */
X#define STARTVAL 64L    /* start by getting enough storage for a few frags */
X
X/* typedef short BOOL */        /* this is in include/exec/types.h */
X
Xstruct IntuitionBase *IntuitionBase ;
Xstruct Window *window ;
Xstruct IntuiMessage *message;
X/* struct IntuiMessage *GetMsg(); */        /* in functions.h */
X
Xstruct GfxBase *GfxBase ;
X
Xextern void InitProjItems();        /* this stuff is in the mminit section */
Xextern void InitSetupItems();
Xextern void InitChipItems();
Xextern void InitChipAItems();
Xextern void InitSFItems();
Xextern void InitSFAItems();
Xextern void InitFastItems();
Xextern void InitFastAItems();
Xextern void InitMenu();
Xextern void StartMenus();
X
XBOOL p_mode = 0;              /* preset frags mode = 0, warps mode = 1 */
Xlong p_rate = 2;              /* preset sample interval, secs see menu */
Xlong p_chip = 512;            /* preset chip mem size, kbytes see menu */
Xlong p_chipa = 0;             /* preset chip mem address, kb  see menu */
Xlong p_sf = 512;              /* preset slowfast mem size, kb see menu */
Xlong p_sfa = 0x3000;          /* preset slowfast mem addr, kb see menu */
Xlong p_fast = 2;              /* preset fast mem size, mbytes see menu */
Xlong p_fasta = 2;             /* preset fast mem addr, mbytes see menu */
X
Xstatic BOOL mode;                    /* uninitialized for mode  menu */
Xstatic long delayval;                /* uninitialized for delay menu */
Xstatic long cmemsize;                /* uninitialized for chip  menu */
Xstatic long cmembase;                /* uninitialized for chipa menu */
Xstatic long sfmemsize;               /* uninitialized for sf    menu */
Xstatic long sfmembase;               /* uninitialized for sfa   menu */
Xstatic long fmemsize;                /* uninitialized for fast  menu */
Xstatic long fmembase;                /* uninitialized for fasta menu */
X
Xstatic USHORT log ;
Xstatic BOOL things_are_cool = TRUE ; /* tells when to close the window  */
Xstatic BOOL intsig = FALSE ;         /* intuition message detector */
Xstatic long chip[3], fast[3] ;       /* place to keep mem header pointers */
Xstatic ULONG  *chunkv ;              /* demand allocated for frag chunks */
Xstatic ULONG  *sizev ;               /* demand allocated for frag sizes */
Xstatic ULONG  *csum ;                /* a col's height worth of checksums */
Xstatic ULONG  *oldcsum ;             /* same height worth of old checksums */
Xstatic USHORT *cell;                 /* 1 cell per pixel height of mercury */
Xstatic long x1, x2 ;                 /* used to Draw() memometer segments */
Xstatic long frags = STARTVAL ;       /* # of demand allocated frag items */
Xstatic long warps = BARS ;           /* # of demand allocated column items */
Xstatic long barh = BARH ;            /* EVEN #'d height of mercury column */
Xstatic long barb = BARB ;            /* bottom position of mercury column */
X
X/* struct RastPort *rp ; */          /* wonder why we don't need this... ? */
X
Xstatic struct TextAttr myfont = {
X   (STRPTR) "topaz.font",
X   TOPAZ_EIGHTY,
X   0,
X   0
X};
X/* E newsize gadget refresh text */ 
Xstatic char ebuf[4] = " E " ;
Xstatic struct IntuiText e_text = { 
X   BLUP, WHTP,
X   JAM2, 
X   0, BARE,
X   &myfont,
X   (UBYTE *)ebuf, 
X   NULL 
X};
X/* F title refresh text */
Xstatic char fbuf[4] = " F " ;
Xstatic struct IntuiText f_text = {
X   BLUP, WHTP,
X   JAM2,
X   0, BART,
X   &myfont,
X   (UBYTE *)fbuf,
X   &e_text
X};
Xstatic struct NewWindow newwindow = {
X   0,                                        /* left edge */
X   10,                                       /* top edge */
X   WINW,                                     /* width */
X   WINH,                                     /* height */
X   0,                                        /* detail pen */
X   1,                                        /* block pen */
X   MENUPICK | NEWSIZE,                       /* messages */
X/* WINDOWDEPTH | WINDOWCLOSE */              /* don't use these gads */
X   WINDOWDRAG | WINDOWSIZING | SMART_REFRESH,   /* add a few gadgets */
X   NULL,                                     /* no custom gadgets */
X   NULL,                                     /* default checkmark */
X   (UBYTE *)"F",                             /* title */
X   NULL,                                     /* initialize this! */
X   NULL,                                     /* use screen bitmap */
X   WINW, MINH, WINW, MAXH,                   /* min and max sizes */
X   WBENCHSCREEN } ;                          /* use workbench screen */
X
Xvoid initmenus()
X{
X   (void) InitProjItems();     	        /* Initialize the menu items */
X   (void) InitSetupItems();
X   (void) InitChipItems();
X   (void) InitChipAItems();
X   (void) InitSFItems();
X   (void) InitSFAItems();
X   (void) InitFastItems();
X   (void) InitFastAItems();
X   (void) InitMenu();
X   (void) StartMenus();
X   }
X
Xvoid handle_MENUPICK( class, code )
Xunsigned long class;
Xunsigned int code;
X{
X    unsigned int menunum, itemnum, subnum;
X
X    if (code == MENUNULL) return;
X
X    menunum = MENUNUM( code );
X    itemnum = ITEMNUM( code );
X    subnum  = SUBNUM( code );
X    switch( menunum ) {
X        case 0:
X        switch( itemnum ) {
X            case 0:
X            WindowToFront(window);
X            break;
X
X            case 1:
X            WindowToBack(window);
X            break;
X
X            case 2:
X            things_are_cool = FALSE;
X            break;
X            } /* end of switch ( Project itemnum ) */
X        break;
X
X        case 1:
X        switch( itemnum ) {
X            case 0:
X            switch( subnum ) {
X                case 0:
X                mode = FALSE ;
X                break;
X
X                case 1:
X                mode = TRUE ;
X                break;
X                /* end of switch ( Mode subnum ) */
X                }
X            break;       
X            case 1:
X            switch( subnum ) {
X                case 0:
X                delayval = 36;
X                break;
X
X                case 1:
X                delayval = 72;
X                break;
X
X                case 2:
X                delayval = 180;
X                break;
X
X                case 3:
X                delayval = 360;
X                break;
X                /* end of switch ( Freq subnum ) */
X                }
X            break;       
X            /* end of switch ( Setup itemnum ) */
X            }
X        break;
X
X        case 2:
X        switch( itemnum ) {
X            case 0:
X            cmemsize = 0x000000;
X            break;
X
X            case 1:
X            cmemsize = 0x040000;
X            break;
X
X            case 2:
X            cmemsize = 0x080000;
X            break;
X
X            case 3:
X            cmemsize = 0x100000;
X            break;
X
X            case 4:
X            cmemsize = 0x200000;
X            break;
X            }
X            /* end of switch ( Chip Size itemnum ) */
X        break;
X
X        case 3:
X        switch( itemnum ) {
X            case 0:
X            cmembase = 0x000000;
X            break;
X
X            case 1:
X            cmembase = 0x040000;
X            break;
X
X            case 2:
X            cmembase = 0x080000;
X            break;
X
X            case 3:
X            cmembase = 0x100000;
X            break;
X            }
X            /* end of switch ( Chip Addr itemnum ) */
X        break;
X
X        case 4:
X        switch( itemnum ) {
X            case 0:
X            sfmemsize = 0x000000;
X            break;
X
X            case 1:
X            sfmemsize = 0x080000;
X            break;
X
X            case 2:
X            sfmemsize = 0x100000;
X            break;
X
X            case 3:
X            sfmemsize = 0x180000;
X            break;
X            }
X            /* end of switch ( SF Size itemnum ) */
X        break;
X
X        case 5:
X        switch( itemnum ) {
X            case 0:
X            sfmembase = 0xc00000;
X            break;
X
X            case 1:
X            sfmembase = 0xc80000;
X            break;
X
X            case 2:
X            sfmembase = 0xd00000;
X            break;
X
X            case 3:
X            sfmembase = 0xd80000;
X            break;
X            }
X            /* end of switch ( SF Addr itemnum ) */
X        break;
X
X        case 6:
X        switch( itemnum ) {
X            case 0:
X            fmemsize = 0x000000;
X            break;
X
X            case 1:
X            fmemsize = 0x080000;
X            break;
X
X            case 2:
X            fmemsize = 0x100000;
X            break;
X
X            case 3:
X            fmemsize = 0x200000;
X            break;
X
X            case 4:
X            fmemsize = 0x400000;
X            break;
X
X            case 5:
X            fmemsize = 0x600000;
X            break;
X
X            case 6:
X            fmemsize = 0x800000;
X            break;
X            }
X            /* end of switch ( Fast Size itemnum ) */
X        break;
X
X        case 7:
X        switch( itemnum ) {
X            case 0:
X            fmembase = 0x200000;
X            break;
X
X            case 1:
X            fmembase = 0x300000;
X            break;
X
X            case 2:
X            fmembase = 0x400000;
X            break;
X
X            case 3:
X            fmembase = 0x500000;
X            break;
X
X            case 4:
X            fmembase = 0x600000;
X            break;
X
X            case 5:
X            fmembase = 0x700000;
X            break;
X
X            case 6:
X            fmembase = 0x800000;
X            break;
X
X            case 7:
X            fmembase = 0x900000;
X            break;
X            }
X            /* end of switch ( Fast Addr itemnum ) */
X        break;
X        }
X        /* end of switch ( menunum ) */
X}
X
Xvoid wrack_sploot() /* this subprogram cashes in the chips in bad times */
X    {
X    if (log != 0) {
X        if (log & SA) {
X            (void) FreeMem(oldcsum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & CA ;
X            }
X        if (log & S8) {
X            (void) FreeMem(csum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & C8 ;
X            }
X        if (log & S4)  {
X            (void) FreeMem(sizev, (long)(sizeof(long) * frags)) ;
X            log = log & C4 ;
X            }
X        if (log & S2)  {
X            (void) FreeMem(chunkv, (long)(sizeof(long) * frags)) ;
X            log = log & C2 ;
X            }
X        if (log & S1) {
X            (void) FreeMem(cell, (long)(sizeof(USHORT) * warps)) ;
X            log = log & C1 ;
X            }
X        frags = 0;
X        warps = 0;
X        }
X}
X
Xvoid handle_NEWSIZE()        /* oh rats, the user found the size gadget... */
X    {
X    if (barh != window->Height)  {  /* cash in the old memory allocations  */
X        if (log & SA)  {
X            (void) FreeMem(oldcsum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & CA ;
X            }
X        if (log & S8)  {
X            (void) FreeMem(csum, (long)(sizeof(ULONG) * warps)) ;
X            log = log & C8 ;
X            }
X        if (log & S1)  {
X            (void) FreeMem(cell, (long)(sizeof(USHORT) * warps)) ;
X            log = log & C1 ;
X            }
X        barh = window->Height - SIZEGAD - DRAGBAR ;  /* recalculate height */
X        barb = window->Height - SIZEGAD - 1 ; /* get new bar base position */
X        warps = barh + 1 ;       /* number of storage cells to be reserved */
X        if ((cell = (USHORT *)AllocMem((long)sizeof(USHORT) * warps,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S1;
X        if ((csum = (ULONG *)AllocMem((long)sizeof(ULONG) * warps,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S8;
X        if ((oldcsum = (ULONG *)AllocMem((long)sizeof(ULONG) * warps,
X                                        MEMF_PUBLIC)) != 0L ) log = log | SA;
X        if (log != SOK)  {      /* bail out if we didn't get an allocation */
X            wrack_sploot() ;
X            things_are_cool = FALSE ;     /* tell _main that we're leaving */
X            }
X        e_text.TopEdge = barb + BORDER ;        /* set the E text position */
X        }
X}
X
Xvoid handle_MESSAGES()  {
X    unsigned long class;
X    unsigned int code, qual;
X
X    /* Wait (1L << window->UserPort->mp_SigBit); this is rediculous! */
X    while ((message=(struct IntuiMessage *)GetMsg(window->UserPort))
X                                                                != 0L) {
X        class = message->Class ;
X        code = message->Code ;
X        qual = message->Qualifier ;
X        ReplyMsg ;
X        switch( class ) {
X            case NEWSIZE:
X            intsig = TRUE ;			/* resize when done here */
X            break ;
X
X            case MENUPICK:
X            handle_MENUPICK( class, code ) ;    /* do menus ASAP */
X            break ;
X            }
X        }
X}
X
Xvoid memometer()                /* this subprogram draws the bar graphs */
X    {
X    long i;
X    long y;
X
X    i = 0 ;
X    while ((i < barh) && (intsig == FALSE)) {
X        y = barb - i ;
X        SetAPen(window->RPort, (long)cell[i]);
X        Move(window->RPort, x1, y);
X        Draw(window->RPort, x2, y);
X        (void) handle_MESSAGES() ;  /* go see if the user wants anything */
X        i++ ;
X        }
X}
X
Xvoid shake()    /* this subprogram slings down the mercury column */
X    {
X    int i;
X
X    for (i = 0; i < barh; i++)  {
X        cell[i] = REDP ;
X        }
X}
X
Xvoid lockout()  /* this subprogram renders a whole column in border colors */
X    {
X    (void) handle_MESSAGES() ;        /* go see if the user wants anything */
X    SetAPen(window->RPort, WHTP) ;    /* set in the border color */
X    RectFill(window->RPort, x1, (barb - barh + 1), x2, barb) ; /* fill in */
X}
X
Xvoid updatewarps( wf, membase, memseg )  /* this subprogram finds changes */
Xshort wf;
Xlong membase, memseg ;
X    {
X    register long i ;
X    register ULONG r ;
X    register ULONG delta ;
X    register ULONG *a ;
X
X    if (memseg == 0) {
X        (void) lockout() ;
X        return ;
X        }
X    else (void) shake() ;
X
X    delta = (ULONG)(memseg & EVENMASK) ;  /* try to avoid odd address trap */
X    r = (ULONG)(membase & EVENMASK) ;     /* prefer wrong address to death */
X    for (i = 0; i < barh; i++)  {
X        csum[i] = 0 ;
X        }
X    for (i = 0; i < barh; i++)  {
X        for (a = (ULONG *)r; a < (ULONG *)(r + delta); a++)  {
X            csum[i] += *a ;
X            }
X        if (csum[i] == 0) cell[i] = cell[i] & BLUP ;
X        if (csum[i] == oldcsum[i])  cell[i] = cell[i] & BLKP ;
X        oldcsum[i] = csum[i] ;
X        r += delta ;
X        }
X    (void) memometer();
X}
X
Xvoid updatescreen( wf, membase, memseg )
Xshort wf;
Xlong membase, memseg;
X    {
X    register long size ;
X    register struct MemHeader *hdr ;
X    register struct MemChunk *chunk ;
X    extern struct ExecBase *SysBase ;
X    register long *which ;                /* active memlist chunk pointer */
X    register long newlimit ;  /* number of chunks, incl 1 null chunk, + 1 */
X    register long newfrags ;  /* number of chunks, incl null chunks, + 1  */
X    long newsize ;  /* size of next request for chunkv/sizev memory, + 1  */
X    int i, j, k, l ;
X    int length ;       /* length is number of chunks to be processed, + 1 */
X    BOOL cf, nf ;      /* cf is "chip flag" nf is "null chunk found" flag */
X
X    if (memseg == 0) {
X        (void) lockout() ;
X        return;
X        }
X    else (void) shake() ;
X
X    for (i = 0; i < 3; i++) {
X        chip[i] = 0;
X        fast[i] = 0;
X        }
X    for (i = 0; i < frags; i++) {
X        chunkv[i] = 0;
X        sizev[i] = 0;
X        }
X    newfrags = 0 ;
X    newlimit = 0 ;
X    nf = FALSE;
X    Forbid() ;
X    hdr = (struct MemHeader *) SysBase->MemList.lh_Head ;
X    while (hdr->mh_Node.ln_Succ) {
X        if (hdr->mh_Attributes & MEMF_CHIP) {
X            which = chip ;
X            cf = TRUE;
X            }
X        else {
X            which = fast ;
X            cf = FALSE;
X            }
X        if (((cf == TRUE) && (wf == 0)) || ((cf == FALSE) && (wf > 0)))  {
X            for (chunk = hdr->mh_First; chunk; chunk = chunk->mc_Next) {
X                if (which[1] < frags)  chunkv[which[1]++] = (unsigned long)chunk ;
X                size = chunk->mc_Bytes ;
X                if (which[2] < frags)  sizev[which[2]++] = (unsigned long)size;
X                *which += size ;
X                if (nf == FALSE)  {
X                    newlimit++ ;
X                    if (chunkv[newfrags] == NULL)  {
X                        nf = TRUE;
X                        }
X                    }
X                newfrags++ ;
X            }
X        }
X        hdr = (struct MemHeader *)hdr->mh_Node.ln_Succ ;
X        }
X    Permit() ;
X    length = frags ;
X    if (newlimit < frags)  length = newlimit ;
X    for (i = 0; i < length; i++)  {
X        chunkv[i] -= membase;   /* chunkv is now array offset from base   */
X        sizev[i] += chunkv[i];  /* and sizev is now address of array top  */
X        chunkv[i] = chunkv[i] / memseg;  /* this is the number of pixels  */
X        sizev[i] = sizev[i] / memseg;       /* and this is the top pixel  */
X        if (chunkv[i] < 0) chunkv[i] = 0 ;  /* we do some bounds checking */
X        if (sizev[i] < 0) sizev[i] = 0 ;
X        if (chunkv[i] >= barh) chunkv[i] = barh - 1 ;
X        if (sizev[i] >= barh) sizev[i] = barh - 1 ;
X        if (sizev[i] - chunkv[i] < 0)  sizev[i] = chunkv[i] ;
X        j = chunkv[i] ; /* from now on it will be less confusing if */
X        k = sizev[i] ;  /* we assign some variables for this stuff  */
X        if (sizev[i] - chunkv[i] == 0)  {
X            cell[j] = cell[j] & BLUP ;
X            }
X        else  {
X            for (l = j; l < k; l++)  {
X                cell[l] = cell[l] & BLKP ;
X                }
X            }
X        }
X    (void) memometer();
X    newsize = frags ;
X    while (newsize < newlimit)  {
X        newsize += EXTENSION ;
X        }
X    if (newlimit > frags)  {
X        (void) FreeMem(chunkv, (long)(sizeof(long) * frags));
X        if ((chunkv = (unsigned long *)AllocMem((long)sizeof(long) * newsize,
X                                        MEMF_PUBLIC)) == 0L )  {
X            log = log & C2 ;
X            }
X        (void) FreeMem(sizev, (long)(sizeof(long) * frags));
X        if ((sizev = (unsigned long *)AllocMem((long)sizeof(long) * newsize,
X                                        MEMF_PUBLIC)) == 0L ) {
X            (void) FreeMem(chunkv, (long)(sizeof(long) * newsize));
X            log = log & C4 ;
X            }
X        if (log != SOK)  {
X            wrack_sploot() ;
X            things_are_cool = FALSE ;
X            }
X        else frags = newsize ;
X        }
X}
X
Xmain() {
X    int i;
X    short wf;
X    long cmemseg;
X    long sfmemseg;
X    long fmemseg;
X    long membase;
X    long memseg;
X    long memsize;
X
X
X    log = 0 ;
X    if ((cell = (USHORT *)AllocMem((long)sizeof(USHORT) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S1;
X    if ((chunkv = (ULONG *)AllocMem((long)sizeof(ULONG) * STARTVAL,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S2;
X    if ((sizev = (ULONG *)AllocMem((long)sizeof(ULONG) * STARTVAL,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S4;
X    if ((csum = (ULONG *)AllocMem((long)sizeof(ULONG) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | S8;
X    if ((oldcsum = (ULONG *)AllocMem((long)sizeof(ULONG) * BARS,
X                                        MEMF_PUBLIC)) != 0L ) log = log | SA;
X    if (log != SOK)  {
X        wrack_sploot() ;
X        Exit() ;
X        }
X    if ((IntuitionBase = (struct IntuitionBase *)OpenLibrary(
X            "intuition.library",33L)) != NULL &&
X            (window=OpenWindow(&newwindow)) != NULL)  {
X        if ((GfxBase = (struct GfxBase *)OpenLibrary(
X                "graphics.library", 0L)) != NULL)  { 
X            (void) initmenus();
X            /* rp = window->RPort ; */
X            wf = 0;
X            mode = p_mode ;
X            delayval = p_rate * 36 ;
X            cmemsize = p_chip << 10 ;
X            cmembase = p_chipa << 10 ;
X            sfmemsize = p_sf << 10 ;
X            sfmembase = p_sfa << 10 ;
X            if (p_fast >= 512)  fmemsize = p_fast << 10 ;
X            else fmemsize = p_fast << 20 ;
X            fmembase = p_fasta << 20 ;
X            while (things_are_cool == TRUE) {
X                cmemseg = cmemsize / barh ;
X                sfmemseg = sfmemsize / barh ;
X                fmemseg = fmemsize / barh ;
X                switch ( wf ) {
X                    case 0:
X                    x1 = LEFT ;
X                    membase = cmembase ;
X                    memseg = cmemseg ;
X                    memsize = cmemsize ;
X                    break;
X
X                    case 1:
X                    x1 = MIDDLE ;
X                    membase = sfmembase ;
X                    memseg = sfmemseg ;
X                    memsize = sfmemsize ;
X                    break;
X
X                    case 2:
X                    x1 = RIGHT ;
X                    membase = fmembase ;
X                    memseg = fmemseg ;
X                    memsize = fmemsize ;
X                    break;
X                    }
X                x2 = x1 + BARW ;
X                if (mode == TRUE)  {
X                    (void) updatewarps( wf, membase, memseg ) ;
X                    }
X                if (mode == FALSE)  {
X                    (void) updatescreen( wf, membase, memseg ) ;
X                    }
X                if (intsig == TRUE)  {
X                    handle_NEWSIZE() ;
X                    intsig = FALSE ;
X                    }
X                if (wf == 2)  {
X                    PrintIText(window->RPort,&f_text,RTEXT,0L) ;
X                    Delay(delayval) ;
X                    }
X                wf++ ;
X                if (wf >= 3)  wf = 0 ;
X                } /* end of while ( things_are_cool) */
X            wrack_sploot() ;
X            }
X        if (GfxBase)    CloseLibrary(GfxBase) ;
X        }
X    if (window)         CloseWindow(window) ;
X    if (IntuitionBase)  CloseLibrary(IntuitionBase) ;
X}
X_cli_parse() {}
X_wb_parse() {}
//END_OF_FILE
echo x - mminit3.c
sed 's/^X//' > mminit3.c << '//END_OF_FILE'
X/* : ai=0 bk=0 ts=8 */
X#include "mm.h"
X
X#define PROJMAX 3               /* number of project menu items */
X#define SETUPMAX 2              /* number of setup menu items */
X#define MODEMAX 2
X#define FREQMAX 4               /* number of frequency menu items */
X#define CHIPMAX 5               /* number of chip mem size menu items */
X#define CHIPAMAX 4              /* number of chip mem base addr menu items */
X#define SFMAX 4                 /* number of sf mem size menu items */
X#define SFAMAX 4                /* number of sf mem base addr menu items */
X#define FASTMAX 7               /* number of fast mem size menu items */
X#define FASTAMAX 8              /* number of fast mem base addr menu items */
X#define MAXMENU 9               /* total number of top level menus */
X
Xextern BOOL p_mode;             /* preset frags mode = 0, warps mode = 1 */
Xextern long p_rate;             /* preset sample interval, secs see menu */
Xextern long p_chip;             /* preset chip mem size, kbytes see menu */
Xextern long p_chipa;            /* preset chip mem address, kb  see menu */
Xextern long p_sf;               /* preset slowfast mem size, kb see menu */
Xextern long p_sfa;              /* preset slowfast mem addr, kb see menu */
Xextern long p_fast;             /* preset fast mem size, mbytes see menu */
Xextern long p_fasta;            /* preset fast mem addr, mbytes see menu */
X
X/******************************************************/
X/*    Structure declarations for the menu sections    */
X/******************************************************/
X
Xstruct   MenuItem ProjItem[PROJMAX];
Xstruct   IntuiText ProjText[PROJMAX];
Xstruct   MenuItem SetupItem[SETUPMAX];
Xstruct   IntuiText SetupText[SETUPMAX];
Xstruct   MenuItem ModeItem[MODEMAX];
Xstruct   IntuiText ModeText[MODEMAX];
Xstruct   MenuItem FreqItem[FREQMAX];
Xstruct   IntuiText FreqText[FREQMAX];
Xstruct   MenuItem ChipItem[CHIPMAX];
Xstruct   IntuiText ChipText[CHIPMAX];
Xstruct   MenuItem ChipAItem[CHIPAMAX];
Xstruct   IntuiText ChipAText[CHIPAMAX];
Xstruct   MenuItem SFItem[SFMAX];
Xstruct   IntuiText SFText[SFMAX];
Xstruct   MenuItem SFAItem[SFAMAX];
Xstruct   IntuiText SFAText[SFAMAX];
Xstruct   MenuItem FastItem[FASTMAX];
Xstruct   IntuiText FastText[FASTMAX];
Xstruct   MenuItem FastAItem[FASTAMAX];
Xstruct   IntuiText FastAText[FASTAMAX];
Xstruct   Menu menu[MAXMENU];
X
X/*****************************************************************/
X/*    The following function initializes the structure arrays    */
X/*    needed to provide the Project menu topic.                  */
X/*    this was left retro-compatible with Manx 3.4a (nplus1)     */
X/*****************************************************************/
Xvoid InitProjItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<PROJMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ProjItem[n].NextItem = &ProjItem[nplus1];
X    ProjItem[n].LeftEdge = 0;
X    ProjItem[n].TopEdge = 9 * n;
X    ProjItem[n].Width = 64;
X    ProjItem[n].Height = 9;
X    ProjItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP;
X    ProjItem[n].MutualExclude = 0;
X    ProjItem[n].ItemFill = (APTR)&ProjText[n];
X    ProjItem[n].SelectFill = NULL;
X    ProjItem[n].Command = 0;
X    ProjItem[n].SubItem = NULL;
X    ProjItem[n].NextSelect = 0;
X
X    ProjText[n].FrontPen = 0;
X    ProjText[n].BackPen = 1;
X    ProjText[n].DrawMode = JAM2;/* render in fore and background */
X    ProjText[n].LeftEdge = 0;
X    ProjText[n].TopEdge = 1;
X    ProjText[n].ITextFont = NULL;
X    ProjText[n].NextText = NULL;
X    }
XProjItem[PROJMAX-1].NextItem = NULL;
X
X/* initialize text for specific menu items */
X
XProjText[0].IText = (UBYTE *)"Front";
XProjText[1].IText = (UBYTE *)"Back";
XProjText[2].IText = (UBYTE *)"Close";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Setup menu topic.                     */
X/*****************************************************************/
X
Xvoid InitSetupItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SETUPMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SetupItem[n].NextItem = &SetupItem[nplus1];
X    SetupItem[n].LeftEdge = 0;
X    SetupItem[n].TopEdge = 9 * n;
X    SetupItem[n].Width = 44;
X    SetupItem[n].Height = 9;
X    SetupItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP ;
X    SetupItem[n].MutualExclude = 0;
X    SetupItem[n].ItemFill = (APTR)&SetupText[n];
X    SetupItem[n].SelectFill = NULL;
X    SetupItem[n].Command = 0;
X    SetupItem[n].NextSelect = 0;
X
X    SetupText[n].FrontPen = 0;
X    SetupText[n].BackPen = 1;
X    SetupText[n].DrawMode = JAM2;    
X    SetupText[n].LeftEdge = 0;
X    SetupText[n].TopEdge = 1;
X    SetupText[n].ITextFont = NULL;
X    SetupText[n].NextText = NULL;
X    }
XSetupItem[SETUPMAX-1].NextItem = NULL;
X
XSetupText[0].IText = (UBYTE *)"Mode";
XSetupItem[0].SubItem = ModeItem;
XSetupText[1].IText = (UBYTE *)"Freq";
XSetupItem[1].SubItem = FreqItem;
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Mode submenu topic.                   */
X/*****************************************************************/
X
Xfor( n=0; n<MODEMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ModeItem[n].NextItem = &ModeItem[nplus1];
X    ModeItem[n].LeftEdge = 38;
X    ModeItem[n].TopEdge = 9 * n;
X    ModeItem[n].Width = 72;
X    ModeItem[n].Height = 9;
X    ModeItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ModeItem[n].MutualExclude = (~(1 << n));
X    ModeItem[n].ItemFill = (APTR)&ModeText[n];
X    ModeItem[n].SelectFill = NULL;
X    ModeItem[n].Command = 0;
X    ModeItem[n].SubItem = NULL;
X    ModeItem[n].NextSelect = 0;
X
X    ModeText[n].FrontPen = 0;
X    ModeText[n].BackPen = 1;
X    ModeText[n].DrawMode = JAM2;     /* render in fore and background */
X    ModeText[n].LeftEdge = 0;
X    ModeText[n].TopEdge = 1;
X    ModeText[n].ITextFont = NULL;
X    ModeText[n].NextText = NULL;
X    }
XModeItem[MODEMAX-1].NextItem = NULL;
X
X/* select mode subitem checked */
Xswitch (p_mode) {
X    case 0:     n = 0; break;
X    case 1:     n = 1; break;
X    default:    n = 1; p_mode = FALSE;
X    }
XModeItem[n].Flags |= CHECKED;
X
X/* initialize text for specific submenu items */
XModeText[0].IText = (UBYTE *)"   Frags";
XModeText[1].IText = (UBYTE *)"   Warps";
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Freq submenu topic.                   */
X/*****************************************************************/
X
Xfor( n=0; n<FREQMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FreqItem[n].NextItem = &FreqItem[nplus1];
X    FreqItem[n].LeftEdge = 38;
X    FreqItem[n].TopEdge = 9 * n;
X    FreqItem[n].Width = 88;
X    FreqItem[n].Height = 9;
X    FreqItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FreqItem[n].MutualExclude = (~(1 << n));
X    FreqItem[n].ItemFill = (APTR)&FreqText[n];
X    FreqItem[n].SelectFill = NULL;
X    FreqItem[n].Command = 0;
X    FreqItem[n].SubItem = NULL;
X    FreqItem[n].NextSelect = 0;
X
X    FreqText[n].FrontPen = 0;
X    FreqText[n].BackPen = 1;
X    FreqText[n].DrawMode = JAM2;     /* render in fore and background */
X    FreqText[n].LeftEdge = 0;
X    FreqText[n].TopEdge = 1;
X    FreqText[n].ITextFont = NULL;
X    FreqText[n].NextText = NULL;
X    }
XFreqItem[FREQMAX-1].NextItem = NULL;
X
X/* select frequency item checked */
Xswitch (p_rate) {
X    case 1:     n = 0; break;
X    case 2:     n = 1; break;
X    case 5:     n = 2; break;
X    case 10:    n = 3; break;
X    default:    n = 1; p_rate = 2;
X    }
XFreqItem[n].Flags |= CHECKED;
X
X/* initialize text for specific menu items */
XFreqText[0].IText = (UBYTE *)"    1 Sec ";
XFreqText[1].IText = (UBYTE *)"    2 Secs";
XFreqText[2].IText = (UBYTE *)"    5 Secs";
XFreqText[3].IText = (UBYTE *)"   10 Secs";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Chip Mem Size menu topic.             */
X/*****************************************************************/
X
Xvoid InitChipItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<CHIPMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ChipItem[n].NextItem = &ChipItem[nplus1];
X    ChipItem[n].LeftEdge = 0;
X    ChipItem[n].TopEdge = 9 * n;
X    ChipItem[n].Width = 80;
X    ChipItem[n].Height = 9;
X    ChipItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ChipItem[n].MutualExclude = (~(1 << n));
X    ChipItem[n].ItemFill = (APTR)&ChipText[n];
X    ChipItem[n].SelectFill = NULL;
X    ChipItem[n].Command = 0;
X    ChipItem[n].NextSelect = 0;
X
X    ChipText[n].FrontPen = 0;
X    ChipText[n].BackPen = 1;
X    ChipText[n].DrawMode = JAM2;    
X    ChipText[n].LeftEdge = 0;
X    ChipText[n].TopEdge = 1;
X    ChipText[n].ITextFont = NULL;
X    ChipText[n].NextText = NULL;
X    }
XChipItem[CHIPMAX-1].NextItem = NULL;
X
X/* select chip mem size item checked */
Xswitch (p_chip) {
X    case    0:     n = 0; break;
X    case  256:     n = 1; break;
X    case  512:     n = 2; break;
X    case 1024:     n = 3; break;
X    case 2048:     n = 4; break;
X    default:       n = 2; p_chip = 512;
X    }
XChipItem[n].Flags |= CHECKED;
X
XChipText[0].IText = (UBYTE *)"   NONE";
XChipText[1].IText = (UBYTE *)"   256K";
XChipText[2].IText = (UBYTE *)"   512K";
XChipText[3].IText = (UBYTE *)"   1 MB";
XChipText[4].IText = (UBYTE *)"   2 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Chip Base Addr menu topic.            */
X/*****************************************************************/
X
Xvoid InitChipAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<CHIPAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    ChipAItem[n].NextItem = &ChipAItem[nplus1];
X    ChipAItem[n].LeftEdge = 0;
X    ChipAItem[n].TopEdge = 9 * n;
X    ChipAItem[n].Width = 80;
X    ChipAItem[n].Height = 9;
X    ChipAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    ChipAItem[n].MutualExclude = (~(1 << n));
X    ChipAItem[n].ItemFill = (APTR)&ChipAText[n];
X    ChipAItem[n].SelectFill = NULL;
X    ChipAItem[n].Command = 0;
X    ChipAItem[n].NextSelect = 0;
X
X    ChipAText[n].FrontPen = 0;
X    ChipAText[n].BackPen = 1;
X    ChipAText[n].DrawMode = JAM2;    
X    ChipAText[n].LeftEdge = 0;
X    ChipAText[n].TopEdge = 1;
X    ChipAText[n].ITextFont = NULL;
X    ChipAText[n].NextText = NULL;
X    }
XChipAItem[CHIPAMAX-1].NextItem = NULL;
X
X/* select chip base address item checked */
Xswitch (p_chipa) {
X    case    0:     n = 0; break;
X    case  256:     n = 1; break;
X    case  512:     n = 2; break;
X    case 1024:     n = 3; break;
X    default:       n = 0; p_chipa = 0;
X    }
XChipAItem[n].Flags |= CHECKED;
X
XChipAText[0].IText = (UBYTE *)"   @   0K";
XChipAText[1].IText = (UBYTE *)"   @ 256K";
XChipAText[2].IText = (UBYTE *)"   @ 512K";
XChipAText[3].IText = (UBYTE *)"   @ 1 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Slow Fast Mem Size menu topic.        */
X/*****************************************************************/
X
Xvoid InitSFItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SFMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SFItem[n].NextItem = &SFItem[nplus1];
X    SFItem[n].LeftEdge = 0;
X    SFItem[n].TopEdge = 9 * n;
X    SFItem[n].Width = 80;
X    SFItem[n].Height = 9;
X    SFItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    SFItem[n].MutualExclude = (~(1 << n));
X    SFItem[n].ItemFill = (APTR)&SFText[n];
X    SFItem[n].SelectFill = NULL;
X    SFItem[n].Command = 0;
X    SFItem[n].NextSelect = 0;
X
X    SFText[n].FrontPen = 0;
X    SFText[n].BackPen = 1;
X    SFText[n].DrawMode = JAM2;    
X    SFText[n].LeftEdge = 0;
X    SFText[n].TopEdge = 1;
X    SFText[n].ITextFont = NULL;
X    SFText[n].NextText = NULL;
X    }
XSFItem[SFMAX-1].NextItem = NULL;
X
X/* select slow fast mem size item checked */
Xswitch (p_sf) {
X    case    0:     n = 0; break;
X    case  512:     n = 1; break;
X    case 1024:     n = 2; break;
X    case 1536:     n = 3; break;
X    default:       n = 1; p_sf = 512;
X    }
XSFItem[n].Flags |= CHECKED;
X
XSFText[0].IText = (UBYTE *)"   NONE  ";
XSFText[1].IText = (UBYTE *)"   0.5 MB";
XSFText[2].IText = (UBYTE *)"   1   MB";
XSFText[3].IText = (UBYTE *)"   1.5 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Slow Fast Mem Base Addr menu topic.   */
X/*****************************************************************/
X
Xvoid InitSFAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<SFAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    SFAItem[n].NextItem = &SFAItem[nplus1];
X    SFAItem[n].LeftEdge = 0;
X    SFAItem[n].TopEdge = 9 * n;
X    SFAItem[n].Width = 104;
X    SFAItem[n].Height = 9;
X    SFAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    SFAItem[n].MutualExclude = (~(1 << n));
X    SFAItem[n].ItemFill = (APTR)&SFAText[n];
X    SFAItem[n].SelectFill = NULL;
X    SFAItem[n].Command = 0;
X    SFAItem[n].NextSelect = 0;
X
X    SFAText[n].FrontPen = 0;
X    SFAText[n].BackPen = 1;
X    SFAText[n].DrawMode = JAM2;    
X    SFAText[n].LeftEdge = 0;
X    SFAText[n].TopEdge = 1;
X    SFAText[n].ITextFont = NULL;
X    SFAText[n].NextText = NULL;
X    }
XSFAItem[SFAMAX-1].NextItem = NULL;
X
X/* select slow fast mem base address item checked */
Xswitch (p_sfa) {
X    case 12288:     n = 0; break;               /* 0x3000 kb = 12   mb */
X    case 12800:     n = 1; break;               /* 0x3200 kb = 12.5 mb */
X    case 13312:     n = 2; break;               /* 0x3400 kb = 13   mb */
X    case 13824:     n = 3; break;               /* 0x3600 kb = 13.5 mb */
X    default:        n = 0; p_sfa = 12288;
X    }
XSFAItem[n].Flags |= CHECKED;
X
XSFAText[0].IText = (UBYTE *)"   @ C.0 Meg";
XSFAText[1].IText = (UBYTE *)"   @ C.8 Meg";
XSFAText[2].IText = (UBYTE *)"   @ D.0 Meg";
XSFAText[3].IText = (UBYTE *)"   @ D.8 Meg";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Fast Mem Size menu topic.             */
X/*****************************************************************/
X
Xvoid InitFastItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<FASTMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FastItem[n].NextItem = &FastItem[nplus1];
X    FastItem[n].LeftEdge = 0;
X    FastItem[n].TopEdge = 9 * n;
X    FastItem[n].Width = 80;
X    FastItem[n].Height = 9;
X    FastItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FastItem[n].MutualExclude = (~(1 << n));
X    FastItem[n].ItemFill = (APTR)&FastText[n];
X    FastItem[n].SelectFill = NULL;
X    FastItem[n].Command = 0;
X    FastItem[n].NextSelect = 0;
X
X    FastText[n].FrontPen = 0;
X    FastText[n].BackPen = 1;
X    FastText[n].DrawMode = JAM2;    
X    FastText[n].LeftEdge = 0;
X    FastText[n].TopEdge = 1;
X    FastText[n].ITextFont = NULL;
X    FastText[n].NextText = NULL;
X    }
XFastItem[FASTMAX-1].NextItem = NULL;
X
X/* select fast mem size item checked */
Xswitch (p_fast) {
X    case 0:       n = 0; break;
X    case 512:     n = 1; break;
X    case 1:       n = 2; break;
X    case 2:       n = 3; break;
X    case 4:       n = 4; break;
X    case 6:       n = 5; break;
X    case 8:       n = 6; break;
X    default:      n = 3; p_fast = 2;
X    }
XFastItem[n].Flags |= CHECKED;
X
XFastText[0].IText = (UBYTE *)"   NONE";
XFastText[1].IText = (UBYTE *)"   512K";
XFastText[2].IText = (UBYTE *)"   1 MB";
XFastText[3].IText = (UBYTE *)"   2 MB";
XFastText[4].IText = (UBYTE *)"   4 MB";
XFastText[5].IText = (UBYTE *)"   6 MB";
XFastText[6].IText = (UBYTE *)"   8 MB";
X}
X
X/*****************************************************************/
X/*    The following initializes the structure arrays             */
X/*   needed to provide the Fast Mem Base Addr menu topic.        */
X/*****************************************************************/
X
Xvoid InitFastAItems()
X    {
X    int       n,nplus1;
X
X/* initialize each menu item and IntuiText with loop */
Xfor( n=0; n<FASTAMAX; n++ )
X    {
X    nplus1 = n + 1;
X    FastAItem[n].NextItem = &FastAItem[nplus1];
X    FastAItem[n].LeftEdge = 0;
X    FastAItem[n].TopEdge = 9 * n;
X    FastAItem[n].Width = 80;
X    FastAItem[n].Height = 9;
X    FastAItem[n].Flags = ITEMTEXT | ITEMENABLED | HIGHCOMP | CHECKIT;
X    FastAItem[n].MutualExclude = (~(1 << n));
X    FastAItem[n].ItemFill = (APTR)&FastAText[n];
X    FastAItem[n].SelectFill = NULL;
X    FastAItem[n].Command = 0;
X    FastAItem[n].NextSelect = 0;
X
X    FastAText[n].FrontPen = 0;
X    FastAText[n].BackPen = 1;
X    FastAText[n].DrawMode = JAM2;    
X    FastAText[n].LeftEdge = 0;
X    FastAText[n].TopEdge = 1;
X    FastAText[n].ITextFont = NULL;
X    FastAText[n].NextText = NULL;
X    }
XFastAItem[FASTAMAX-1].NextItem = NULL;
X
X/* select fast base address item checked */
Xswitch (p_fasta) {
X    case 2:     n = 0; break;
X    case 3:     n = 1; break;
X    case 4:     n = 2; break;
X    case 5:     n = 3; break;
X    case 6:     n = 4; break;
X    case 7:     n = 5; break;
X    case 8:     n = 6; break;
X    case 9:     n = 7; break;
X    default:    n = 0; p_fasta = 2;
X    }
XFastAItem[n].Flags |= CHECKED;
X
XFastAText[0].IText = (UBYTE *)"   @ 2 M";
XFastAText[1].IText = (UBYTE *)"   @ 3 M";
XFastAText[2].IText = (UBYTE *)"   @ 4 M";
XFastAText[3].IText = (UBYTE *)"   @ 5 M";
XFastAText[4].IText = (UBYTE *)"   @ 6 M";
XFastAText[5].IText = (UBYTE *)"   @ 7 M";
XFastAText[6].IText = (UBYTE *)"   @ 8 M";
XFastAText[7].IText = (UBYTE *)"   @ 9 M";
X}
X
X/****************************************************************/
X/*   The following function inits the Menu structure array with */
X/*  appropriate values for our simple menu.  Review the manual  */
X/*  if you need to know what each value means.                  */
X/****************************************************************/
Xvoid InitMenu()
X{
Xmenu[0].NextMenu = &menu[1];
Xmenu[0].LeftEdge = 4;
Xmenu[0].TopEdge = 0;
Xmenu[0].Width = 64;
Xmenu[0].Height = 10;
Xmenu[0].Flags = MENUENABLED;
Xmenu[0].MenuName = "Project";        /* text for menu-bar display */
Xmenu[0].FirstItem = &ProjItem[0]; /* pointer to first item in list */
X
Xmenu[1].NextMenu = &menu[2];
Xmenu[1].LeftEdge = 68;
Xmenu[1].TopEdge = 0;
Xmenu[1].Width = 48;
Xmenu[1].Height = 10;
Xmenu[1].Flags = MENUENABLED;
Xmenu[1].MenuName = "Setup";   /* text for menu-bar display */
Xmenu[1].FirstItem = &SetupItem[0];  /* pointer to first item in list */
X
Xmenu[2].NextMenu = &menu[3];
Xmenu[2].LeftEdge = 180;
Xmenu[2].TopEdge = 0;
Xmenu[2].Width = 80;
Xmenu[2].Height = 10;
Xmenu[2].Flags = MENUENABLED;
Xmenu[2].MenuName = "Chip Size";        /* text for menu-bar display */
Xmenu[2].FirstItem = &ChipItem[0]; /* pointer to first item in list */
X
Xmenu[3].NextMenu = &menu[4];
Xmenu[3].LeftEdge = 260;
Xmenu[3].TopEdge = 0;
Xmenu[3].Width = 80;
Xmenu[3].Height = 10;
Xmenu[3].Flags = MENUENABLED;
Xmenu[3].MenuName = "Chip Addr";        /* text for menu-bar display */
Xmenu[3].FirstItem = &ChipAItem[0]; /* pointer to first item in list */
X
Xmenu[4].NextMenu = &menu[5];
Xmenu[4].LeftEdge = 340;
Xmenu[4].TopEdge = 0;
Xmenu[4].Width = 64;
Xmenu[4].Height = 10;
Xmenu[4].Flags = MENUENABLED;
Xmenu[4].MenuName = "SF Size";        /* text for menu-bar display */
Xmenu[4].FirstItem = &SFItem[0]; /* pointer to first item in list */
X
Xmenu[5].NextMenu = &menu[6];
Xmenu[5].LeftEdge = 404;
Xmenu[5].TopEdge = 0;
Xmenu[5].Width = 64;
Xmenu[5].Height = 10;
Xmenu[5].Flags = MENUENABLED;
Xmenu[5].MenuName = "SF Addr";        /* text for menu-bar display */
Xmenu[5].FirstItem = &SFAItem[0]; /* pointer to first item in list */
X
Xmenu[6].NextMenu = &menu[7];
Xmenu[6].LeftEdge = 468;
Xmenu[6].TopEdge = 0;
Xmenu[6].Width = 80;
Xmenu[6].Height = 10;
Xmenu[6].Flags = MENUENABLED;
Xmenu[6].MenuName = "Fast Size";      /* text for menu-bar display */
Xmenu[6].FirstItem = &FastItem[0]; /* pointer to first item in list */
X
Xmenu[7].NextMenu = NULL;
Xmenu[7].LeftEdge = 548;
Xmenu[7].TopEdge = 0;
Xmenu[7].Width = 80;
Xmenu[7].Height = 10;
Xmenu[7].Flags = MENUENABLED;
Xmenu[7].MenuName = "Fast Addr";        /* text for menu-bar display */
Xmenu[7].FirstItem = &FastAItem[0]; /* pointer to first item in list */
X
X}
X
Xvoid StartMenus()
X{
XSetMenuStrip(window,&menu[0]);
X}
//END_OF_FILE
echo "End of archive."
# end of archive.
exit 0