Mosinee Upgrade: Part of the GDR Package

Beta Version: 1.0

Date: Tuesday, January 07, 1997

Released Version 2.0

Wednesday, May 14, 1997

Prepared By: Ed Chapman

Contributor of Ideas:

Jean Guy Maltais, "Object Rate Changes"

Dan Larson, "Array Tags[]"

Srini Komandur "Local tags, REALA tags not defined as internal Bailey Tags"

Andre King "Station Tags Additions"

Edwin Chen "ANDC logic for manipulations"

 NFRED mcwiz and mcc

Project: Mosinee, Increase Quality, Increase Productivity, and adding Grade Change Capability.

With the Grade Change product as sold at Mosinee, the need to expand and define more controls over the old "mfpmod" and "mfpcomp". The new task and programs are "mcwiz"(MFP Config Wizard) and "mcc" (MFP Config Compiler). The final version for Mosinee will contain, "mcwiz", "mcc" and a new "gdr" program capable of doing writes from tags to gdr.xxx files. This document only describes, "mfpcomp" and "mfpmod" replacements.

mcc [options] files ....

-d defines from makefile

-o optional object file name

-e optional error file name

-r runrate for object, note: #pragma runrate over-rides this

-l optional listing files

mcwiz [options] object1 object2 object3 .....

 -b break point in hex for debugging

-p priority of mcwiz

-v verbose

-vv or -v -v pretty dam verbose

-s single step mode

Example of use:

mcwiz machinedir.mco mis.mco scanlogic.mco &

The overall concept of the MCWIZ( MFP CONFIGURATION WIZARD) is to run different wizard object at different rates.

Example: mdtag.obj may run at 5 seconds, and scan logic that test for breaks and send scanner offsheet may run at 1 second.

mcwiz mdcfg.mco scanlogic.mco &

Two different module, each with different runrates. All references, i.e. labels and symbols are local to each module with the exception of ATOMs. ATOMs are global, and cross modules for access; therefore these modules can be used as semaphores.

Lets say, you are doing something in object A, and you want to signal someone in object B.

#define SEMA1 100 // a good place to start semaphores is at 100, this leaves 0 through 99 as ATOMs for sigma etc.

moduleA.mcc

  gettagc | pv, mdsomething

ifx

atomadd, SEMA1 // tell some other module to do something

....

....

 moduleB.mcc

atomn, SEMA1

ifx

jsr,$dosomething // someone has set semaphore

atomreset, SEMA1 // always set to 0 and let someone else set.

..

mcwiz moduleA.mco moduleB.mco &

moduleB can now be signaled from moduleA.

Note: The value of ATOMN equals the number of time the semaphore was hit.

The recommendation is that all semaphores be set to 100 or above; leaving 0 through 99 as mis or misc. type atoms used for accumulations spreads and such.

Commenting a line is done using //

Example:

gettag | pv, i23010p00e0000 // get the aplus current mode

Lines that may need longer length than practical, with a normal editor, can be continued with a \

Example:

@tagarray TAGA i23010p00e0000, i23010p00e0001, i23010p00e0002 \

i23010p00e0003, i23010p00e0004

The mcc programming languages is based on the old mfpmod code; making it easy to upgrade. The differences from the old mfpmod code are:

#define

#undefine

#ifdef, #elseif, #else, #endif

The use of wizmac.mcch making code listings more readable.

The use of indirection into ARRAYS or either TAG ARRAYS or LOCAL TAG ARRAYS.

The addition of REPDI, repeating instructions and the actual DI(Data Index) register. In general, any instruction which once did constant addressing can be done in addition to local constants indirection’s to REALA.

Example:

  IFGEC, IFLEC etc. where ‘C’ defines constant can now additionally be done as

@ConstTable REALA 1,2,3,4,5,10,20,30,40

ifgec,@ConstTable // default to [0]

 or

ifgec,@ConstTable,0 // force to [0]

 or

clrdi

ifgec,@ConstTable,di

The same is true with instruction which normally one address Bailey tags.

Example:

GETTAG, IFGE, IFGL where there is no ‘C’ i.e. meaning tag addressing

@TagTable TAGA i23010p00e0000, i23010p00e0001

gettag | pv, i23010p00e0000

ifge | pv,i23010p00e0001

or

gettag | pv, @TagTable

ifge | pv, @TagTable,1

or

clrdi

gettag | pv, @TagTable,di

incdi

ifge | pv, @TagTable,di

The next big changes are PUSH and POP... These are extremely powerful instructions, but with power comes danger. These instructions are not for the light hearted. For each PUSH, there must be 1 POP.

A good use of these PUSH/POP instructions might be a scan off sheet check.

Example:

#define OFFSHEET 1

@offsheetTag nop // save location, temp storage

$ScanOffSheetSub

pop, @offsheetTag

loadx,OFFSHEET

ife | pv, @offsheetTag

rtn // same do not sent again

settag | pv, @offsheetTag // send it off it was not

rtn

#define SCANNER1

#ifdef SCANNER1

@off1 TAGA i23010p00e0000

#endif

#ifdef SCANNER2

@off2 TAGA i23010p01e0000

#endif

#ifdef SCANNER3

@off3 TAGA i23010p02e0000

#endif

$main

gettag | pv, reelbreak

ifnx

skip, $main01

#ifdef SCANNER1

push, @off1

jsr,@ScanOffSheetSub

#endif

#ifdef SCANNER2

push, @off2

jsr,@ScanOffSheetSub

#endif

#ifdef SCANNER3

push, @off3

jsr,@ScanOffSheetSub

#endif

$main01

exit

$main must be included; and it does not need to be the first instruction, mcwiz will find it.

Different wizard objects can be run at different rates, each doing different things. In the PUSH/POP example, a #pragma RUNRATE 3 can be added to the file and this example could simply run in a separate module doing just scanner off sheet checking for scanners..

DCB can be retrieved, this is an addition to the pv,sp, etc. This is because, there are certain situations where you do not care is a tag value is 0 or 1, you simply care if it changes.

The old settagc instruction no longer exists, replacement is loadx, constant then settag.

// command line

ACOSH

X = ACOSH(X)

// command line

ACOS

X = ACOS(X)

 // command line

ADD | PV, tagname

// other methods

@tag1 TAGA i23001p00e0000, i23001p0oe0002

ADD | PV, @tag1

 // or

ADD|PV,@tag1,0

 // or clrdi

ADD|PV,@tag1,di

 Results:

// command line

ADDC, 23.0

// Other methods for adding

// other methods

@real1 REALA 1,2

ADDC, @real1

 // or

ADDC, @real1,0

// or clrdi

ADDC,@real1,di

// command line

gettag | pv, i01005p00e0000

ANDC, 2

jsr, dosomething

// command line

ASIN

X = ASIN(X)

This function provides for an operation on the 'X' register only; providing for no support to the tag data base:

// command line

ASINH

X = ASINH(X)

// command line,

ATAN

X = ATAN(X)

// command line

ATANH

X = ATANH(X)

// command line,

COS

X = COS(X)

This function provides for an atomic operation. It functionality zeros N, XSUM, and XSUMSQ. If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMRESET, 1

ATOM #1 is build if not present already, N = 0, XSUM = 0, and XSUMSQ = 0.

This function provides for an atomic operation. It functionality XSUM / N If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMMEAN, 1

X = XSUM / N or ATOM #1

This function provides for an atomic operation. It functionality provide the variation for points added If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMVAR, 1

X = SUM(X - XB) / N

This function provides for an atomic operation. It functionality XSUM If the ATOM defined is not present, the ATOM will be created.

// command line,

TIME

X = XSUM of ATOM 1

This function provides for an atomic operation. It functionality N If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMN, 1

X = N for ATOM 1

This function provides for an atomic operation. It functionality adds a point to a given ATOM. If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMADD, 1

ATOM [1] = N = N + 1, XSUM = XSUM + X, XSUMSQ = XSUMSQ + (X * X)

This function provides for an atomic operation. It functionality 2 sigma value of an ATOM. If the ATOM defined is not present, the ATOM will be created.

// command line,

ATOMSTD, 1

X = 2 of ATOM [1]

 Clears the DI ( Data Index)

 // Command line

clrdi

DI set to 0, X is unchanged

Clears the X register.

// Command line

clrx

X = 0, DI unchanged

This function provides for an operation on the 'X' register only; providing for no support to the tag data base:

// command line

COS

X = COS(X)

This function provides for an operation on the 'X' register only; providing for no support to the tag data base:

; command line

COSH

X = COSH(X)

This function decrements DI.

// command line

DECDI

X is unchanged, DI = DI -1

This function decrements X.

// command line

DECX

DI is unchanged, X = X -1

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, or ZERO must be 'or' with the operand.

// command line

DIV | PV, tagname

// other methods

@tag1 TAGA i23001p00e0000, i23001p0oe0002

DIV | PV, @tag1

// or

DIV|PV,@tag1,0

// or

clrdi

DIV|PV,@tag1,di

This function provides for an operation on the 'X' register from a constant

// command line

DIVC, 23.0

// Other methods for adding

@readtemp REALA 0,1,2,3

DIVC, @readtemp // adds the first be default the [0] location

DIVC, @readtemp,0 // same as above

clrdi

divc, @readtemp,di // same as above

 // command line

EXP

X = EXP(X)

This function provides for a direct exececution of an external program..

Example:

exec reel

  main(argc, char *argv[])

{

....

}

// command line,

EXEC, prog

X is unchanged

Exit or end of program script.:

// command line

EXIT

// command line

FABS

X = FABS(X)

This function provides for an operation on the 'X' register from a station tag.

// command line

getstat | AM, tag auto/manual

  getstat | CR, tag cast / ratio / normal

  getstat | SL, tag station level

  getstat | CS, tag Computer OK status

  getstat | SF, tag Stations fault status output.

  getstat | OT, tag Output. Tracking

  getstat | ML, tag Manaul Interlock

  getstat | BP, tag Bypass Mode

// command line options

getstat | am, dwtcontrol

// optional mode

@stattags TAGA dwtcontrol, moicontrol, refinercontrol

getstat | am, @stattags,0 // gets the first time in the tag array

// or

getstat | am, @stattags,di // gets the first time in the tag array

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or' with the operand.

// command line

GETTAG | PV, tagname

// options methods

@tagtmp TAGA i23010p00e0000, i23010p00e0001, i23010p00e0002

gettag | pv, @tagtmp

// or

gettag | pv, @tagtmp,0

// or

clrdi

gettag | pv, @tagtmp,di

// command line

GETTAGC, 23.0

// Optional methods

@constantTmp REALA 23, 24, 25

gettagc,@constantTmp

// or

gettagc,@constantTmp,0

// or

clrdi

gettag,@constantTmp,di

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or'ed with the operand.

// command line

IFE | PV, tagname

@tagtmp TAGA i23010p00e0000, i23010p00e0001, i23010p00e0002

ife | pv, @tagtmp

 // or

ife | pv, @tagtmp,0

// or

clrdi

ife | pv, @tagtmp,di

 // command line

IFEC, 100.0

// Optional methods

@constantTmp REALA 23, 24, 25

ifec,@constantTmp

// or

ifec,@constantTmp,0

// or

clrdi

ifec,@constantTmp,di

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or'ed with the operand.

// command line

IFG | PV, tagname

// Other methods,

see ife for addressing TAGA (tag array) indirection methods.

This function provides for an operation on the 'X' register from a constant.

// command line

IFGC, 100.0

// Other methods,

see ifec for addressing REALA (real array) indirection methods.

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or'ed with the operand.

// command line

IFGE | PV, tagname

// Other methods,

see ife for addressing TAGA (tag array) indirection methods.

 Results:

This function provides for an operation on the 'X' register from a constant.

// command line

IFGEC, 100.0

// Other methods,

see ifec for addressing REALA (real array) indirection methods.

  Results:

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or'ed with the operand.

// command line

IFL | PV, tagname

// Other methods,

see ife for addressing TAGA (tag array) indirection methods.

This function provides for an operation on the 'X' register from a constant.

// command line,

IFLC, 100.0

// Other methods,

see ifec for addressing REALA (real array) indirection methods.

// command line

IFLE | PV, tagname

// Other methods,

see ife for addressing TAGA (tag array) indirection methods.

 // command line

IFLEC, 100.0

 // Other methods,

see ifec for addressing REALA (real array) indirection methods.

 Results:

If the value of 'X' <= 100.0, then the tagnamez is set to 0.0

// command line

IFX

'X' and the tag are unchanged at the end of this operation.

; command line

IFX

// command line

INCDI

 // command line

INCX

// command line

jsr, $is_scanner_scanning

ifx

// do something

// command line

#define TEN 10

loaddi, TEN

// command line

#define TEN 10

loadx, TEN

  loadx,@some_real_array

loadx,@some_real_array,di

// command line

LOG

This function provides for an operation on the 'X' register from a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, DCB, or ZERO must be 'or'ed with the operand.

// command line

MUL | PV, tagname

// other methods

@tag1 TAGA i23001p00e0000, i23001p0oe0002

MUL | PV, @tag1

// or

MUL, PV,@tag1,0

// or clrdi

MUL|PV,@tag1,di

 // command line

MULC, 23.0

// other methods

@real1 TAGA 1,2

MULC, @real1

// or

MULC, @real1,0

// or clrdi

MULC,@real1,di

X = X * 23.0

// command line

@dum1 NOP 0

Example:

@dumtag1 TAGA i23010p00e0000

@dumtag2 TAGA i23010p01e0000

@dumtag3 TAGA i23010p03e0000

push, @dumtag1

jsr, $offsheet

push, @dumtag2

jsr, $offsheet

push, @dumtag2

jsr, $offsheet

....

...

$offsheet

@dum1 NOP

pop, @dum1

loadx,1

settag | pv, @dum1

rtn

See NOP for for how to use.

X = unchanged, DI is unchanged

This instruction pushes a level of indirection of a specific location,

See NOP for for how to use.

X = unchanged, DI is unchanged

// Command line

@reeldummy REALA 0,0,0,0,0,0,0,0,0,0,0,0 // 12 real dummy

 Examples:

loadx, 10

storex,@realdummy // save to first location

  storex,@realdummy,0 // save to first location

  clrdi

storex,@realdummy,di // save to first location

  storex,@realdummy,1 // save to second location

  clrdi

incdi

storex,@realdummy,di // save to second location

 Results:

X = unchanged, DI is unchanged

Example:

@tjauto TAGA i01005p00e0000, i01005p00e0001, i01005p00e0002, i01005p00e0003, \

i01005p00e0004, i01005p00e0005, i01005p00e0006, i01005p00e0007, \

i01005p00e0008, i01005p00e0009, i01005p00e0010, i01005p00e0011, \

i01005p00e0012, i01005p00e0013, i01005p00e0014, i01005p00e0015, \

i01005p00e0016, i01005p00e0017, i01005p00e0018, i01005p00e0019

#define TWOINSTRUCT 2

#define TJMAXZONES 20

#define AUTO 0

#define MANAUL 1

  loadx, MANUAL

jsr, $setall_tjet

...

$setall_tjet

clrdi

repdi,TWOINSTRUCT, TJMAXZONES

settag | pv, @tjauto,di // first instruction

incdi // second instruction

rtn

// command line

rtn

// command line

RUNRATE

This function provides for an operation on the 'X' register to a tag. Either ALARMHI,, ALARMLO, PV, SP, SPAN, or ZERO must be 'or'ed with the operand.

// command line

SETTAG | PV, tagname

 // see REPDI for indirection use of settag.

// command line,

SIN

X = SIN(X)

This function provides for an operation on the 'X' register only; providing for no support to the tag data base:

// command line,

SINH

X = SINH(X)

Jump to a specific location.

// command line,

SKIP, $lable

X is unchanged.

// command line,

SQR

X = SQR(X) x = square root of x

// command line,

STEP

X = unchanged, DI = unchanged

// command line

SUB | PV, tagname

// other methods

@tag1 TAGA i23001p00e0000, i23001p0oe0002

SUB | PV, @tag1

 // or

SUB|PV,@tag1,0

 // or clrdi

SUB|PV,@tag1,di

 Results:

// command line

SUBC, 23.0

// other methods

@real1 REALA 1,2

SUBCC, @real1

// or

SUBC, @real1,0

// or clrdi

SUBC,@real1,di

  // command line,

TAN

X = TAN(X)

// command line,

TANH

X = TANH(X)

// command line,

TIME

X = TIME units are in military local time 0000 through 2359

This function is useful when computing the local time or difference in time.

// command line,

TIMET

X = (float)time(NULL)

 Standard Macros

#define

#ifdef

#ifndef

#else

#elseif

#endif

#undef

#pragma runrate

Where run rate for the object is given in seconds.

#ifndef _IFMAC_MCCH

#define _IFMAC_MCCH

#define ifx== IFE|PV

#define if!x IFNX

#define ifx> IFG|PV

#define ifx>= IFGE|PV

#define ifx< IFL|PV

#define ifx<= IFLE|PV

#define ifx==c IFEC

#define ifx!=c IFNC

#define ifx>=c IFGEC

#define ifx>c IFGC

#define ifx<=c IFLEC

#define ifx<c IFLC

#define x= LOADX

#define di= LOADDI

#define x}} STOREX

#define x<< GETTAG|PV

#define x>> SETTAG|PV

#endif

The above macros, if include wizmacs.mcch, allow the user to apply a more readable form of logic operation.

The following shows an example of using the actual wizmac.mcch macro files. It will be included within the testit.mco object script.

#include "wizmacs.mcch"

$wiztest

x<<, i23010p00e0000 // test the wizmacs macros.....

ifx==c, 1 // if scanner target is not offsheet

skip, $wizcon1

x=, 1

x>>, i23010p00e0000

$wizcon1

rtn

#ifndef TESTIT_MCCH

#define TESTIT_MCCH

// test out defines

#define ONE_SECOND 1

#define FIVE_SECONDS 5

#define TEN_SECONDS 10

#define SCAN1

#define OFFSHEET 1

#define ONSHEET 3

// #define SCAN2

// #define SCAN3

#endif

//-------------------------------------------------------

// test out include

#include "wizmacs.mcch"

#include "testit.mcch"

//-------------------------------------------------------

// test runrate this object at 1 second interval

#pragma runrate ONE_SECOND

//-------------------------------------------------------

// test out to see if atoms still work

#define MDSPREADMOI 1

#define RANDOM1 1

#define RANDOM2 2

#define RANDOM3 3

#define RANDOM4 4

$atomtest

ATOMRESET, MDSPREADMOI

LOADX,RANDOM1

ATOMADD, MDSPREADMOI

LOADX,RANDOM2

ATOMADD, MDSPREADMOI

LOADX,RANDOM3

ATOMADD, MDSPREADMOI

ATOMVAR, MDSPREADMOI

settag | pv, reeldummy1

ATOMMEAN, MDSPREADMOI

settag | pv, reeldummy2

ATOMSTD, MDSPREADMOI

settag | pv, reeldummy3

ATOMSUM, MDSPREADMOI

settag | pv, reeldummy4

ATOMN, MDSPREADMOI

settag | pv, reeldummy5

ATOMRESET, MDSPREADMOI

rtn

//-------------------------------------------------------

// test out get tags

// this function tests out the get dcb to see if

// scanner 1 has done a complete scan... if the

// scan counter has changed...

#define SCAN1EOS i23001p00e0027

$newscan

@realscanDCB REALA 1

gettag | dcb, SCAN1EOS

ifec, @realscanDCB

skip, @newscan1

storex,@realscanDCB

loadx,1

rtn

@newscan1

clrx

rtn

// test tag array.........

// sets all therma jet zones to manual

#define TWOINSTRUCT 2

#define TJMAXZONE 10

// example of arrary tags

@tjauto TAGA \

i01005p00e0000, i01005p00e0001,i01005p00e0002, i01005p00e0003, \

i01005p00e0004, i01005p00e0005,i01005p00e0006, i01005p00e0007, \

i01005p00e0008, i01005p00e0009

$tjautomanul

clrdi

// example of repeating a number of instructions for a number of times

repdi, TWOINSTRUCT, TJMAXZONE

// example of setting a tag based on di and array of tags

settag | pv, @tjauto, di // instruction 1st

incdi // instruction 2ndw

rtn

$set_tj_to_man

loadx,1

jsr,$tjautomanul

rtn

$set_tj_to_auto

clrx

jsr,$tjautomanul

rtn

//-------------------------------------------------------

// test of pop and push of instructions....

// this can be used to reference levels of indirections

// in sub routines and also to actually chnage instructions

// is necessary....

$offsheet

@scantarget NOP // holds the tag for the target mode

// sample of one level of indirection using pop and push

pop,@scantarget

gettag | sp, @scantarget

ifec, OFFSHEET

rtn

loadx,OFFSHEET

settag | sp, @scantarget

settag | sp, i23010p00e0000

rtn

#ifdef SCAN1

#define SCAN1MODE i23010p00e0000

@scan1off TAGA SCAN1MODE

#endif

#ifdef SCAN2

#define SCAN2MODE i23010p01e0000

@scan1off TAGA SCAN2MODE

#endif

#ifdef SCAN3

#define SCAN1MODE i23010p02e0000

@scan1off TAGA SCAN3MODE

#endif

$all_scan_off

#ifdef SCAN1

push,@scan1off

jsr, $offsheet

#endif

#ifdef SCAN2

push,@scan2off

jsr, $offsheet

#endif

#ifdef SCAN3

push,@scan3off

jsr, $offsheet

#endif

rtn

//-------------------------------------------------------

// test out internal-internal tags, these are called

// nfred tags... they are tags or ordinals

// which only reside within this module and are not

// bailey internal analog or digital...

//

//

@dwtlav1 REALA 1,10,2,20,3,30

$dwtlav

gettag | pv, i23001p00e0000 // get basis wt last avg...

storex,@dwtlav1 // save it into the 0 index of real array

gettag | pv, i23001p00e0002 // get moist last avg...

storex, @dwtlav1,1 // save it into the 1 index of real array

// make a dry wt....

// show em how to direct address a constant

divc,100 // scale to percent

mulc, @dwtlav1 // mult bw

mulc, -1 // make neg

// show em how to effective address of constant

addc, @dwtlav1 // add to basis wt

storex, @dwtlav1, 2 // save it to @dwtlav1 index 2

rtn

//-------------------------------------------------------

// effective addressing

#define _REELDUM1 reeldummy3

@dumtags TAGA reeldummy1, reeldummy2, reeldummy3, reeldummy4

 $effective

loadx,1

settag | pv, @dumtags // save a 1 to the first address

settag | pv, reeldummy2 // or we could do it like this

settag | pv,_REELDUM1 // or we could do this one like this

settag | pv,@dumtags,3 // or like this @dumtags[2]

clrdi

clrx

repdi, 2, 4

add | pv,@dumtags,di

incdi

settag | pv, @dumtags, 3 // set the last one

// now check a condition

gettag | pv, @dumtags // get the first one

ifge |pv , @dumtags,3 // if it is >= last one which it should not be

nop

  ifle |pv , @dumtags,3 // if it is <= last one which it should be

nop

rtn

//-------------------------------------------------------

// Example: see if we just had a break;

//

#define SHEETBREAK misbreak

@breaksig REALA -1

$hasSheetJustBreak

gettag | dcb, SHEETBREAK

ifec, @breaksig // has the dcb changed

skip, $hasChanged

clrx

rtn

$hasChanged

storex,@breaksig // save the dcb

gettag | pv, SHEETBREAK // if sheet break it will return 1

// otherwize it will return 0, just as if

// dcb has not changed

rtn

//-------------------------------------------------------

// test $main as not being placed at the begining...

// binding should find this at this location....

//

// Example: Of #ifdefs

#ifdef SCAN1

#define SYSTEM_HAS_SCANNER

#endif

#ifdef SCAN2

#ifndef SYSTEM_HAS_SCANNER

#define SYSTEM_HAS_SCANNER

#endif

#endif

#ifdef SCAN3

#ifndef SYSTEM_HAS_SCANNER

#define SYSTEM_HAS_SCANNER

#endif

#endif

$main

#ifdef SYSTEM_HAS_SCANNER

jsr, $all_scan_off // test send all scanners offsheet

#endif

jsr, $set_tj_to_man // set all tj zones to manual

jsr, $set_tj_to_auto // set all tj zones to auto

jsr, $newscan // test new scan

ifx

nop // don't really skip if previous

jsr,$dwtlav // test dwtlav....

jsr,$atomtest // test the old atoms...

jsr,$effective // throw some fancy effective addressing of tags

#ifdef SYSTEM_HAS_SCANNER

jsr,$hasSheetJustBreak // has sheet just broke....

ifec, 1

jsr, $all_scan_off // send all scanners offsheet

jsr,$wiztest

 #endif

exit

HEADERS= testit.mcch wizmacs.mcch makefile

SRCBASE= testit

PROG1= $(SRCBASE).mco

SRC1= testit.mcc

SRC2= wiztest.mcc

all: $(PROG1)

 debug: $(PROG1)

mcwiz -s $(PROG1)

 run: $(PROG1)

mcwiz $(PROG1) &

kill:

slay mcwiz

 $(PROG1) : $(SRC1) $(SRC2) $(HEADERS)

mcc -l $(SRCBASE).lst $(SRC1) $(SRC2)

cat $(SRCBASE).lst