~16BIT`no parameters       RARELY USED
 
Selects 16-bit mode for memory emulation and for trace display
and for PROM burning and reading.


{{USAGE}
You will probably not use this command.  It sets up the UniLab to
work with processors that have a 16 bit data bus.  If you have
purchased a disassembler, then either this command or 8BIT has
been "built-in" to your software. 


{{COMMENTS}
16BIT is one word with no space after the 16.  The 16BIT command
changes both the signals put onto the target system's bus by the
UniLab and the way the UniLab displays the trace display.  That
means you need a 28 pin ROM emulation cable, or the 16 bit
emulation will not work.

The HL and LH commands determine the order in which the trace
displays the bytes.   The byte order has already been set for you
by your UniLab DDB software.
~19.2K`no parameters       RARELY USED

Changes bald rate of serial port to 19.2 K baud.  This is the
default.

{{USAGE}
Use after 9.6K to restore the default condition.

You must SAVE-SYS to make the change permanent.

~1AFTER`1AFTER <trigger spec>           
Clears out previous trigger spec and enables trace filtering. 
Only the bus cycle that satisfies the trigger spec and one cycle
immediately after will be kept. 

{{USAGE}
The UniLab stores the trigger cycle and the one immediately
after, every time it sees conditions that match the trigger
specification. The "trigger status display line"  shows how many
cycles have been stored away.  

You have to use S to start the analyzer after setting this
trigger spec.

The UniLab automatically displays the trace after the entire
trace buffer has been filled. 

The disassembler will not work properly on fragments of code. 
The disassembler should be disabled with DASM' while you are
looking at the results of any of the xAFTER commands. 

{{CHECKING THE TRACE}
If you want to see the trace before the buffer has been
completely filled, then press any key to stop the cycle
recording.  Then type in TD to dump the trace, and display part
of it on the screen. 

The trace buffer fills from the bottom, and each new cycle pushes
up the already recorded data.  If you end up with a partially
filled buffer, then the cycles you want to see are in the last
part of the buffer.

{{EXAMPLES

1AFTER 1200 ADR S} 
shows only those cycles with adr =1200 and one cycle following.

{1AFTER 235 TO 560 ADR S}
shows 2 consecutive cycles each time a cycle has an address
between 235 and 560.
~2AFTER`2AFTER  <trigger spec>

Same as 1AFTER except that two cycles are kept immediately
following each trigger cycle.


{{USAGE}
Enables a filtered trace that gives you a little more information
than 1AFTER does. 


{{COMMENTS}
See 1AFTER.

~3AFTER`3AFTER  <trigger spec>

Same as 1AFTER,  except that the three cycles after the trigger
cycle get stored.


{{USAGE}
Enables a filtered trace that gives you a little more information
than 2AFTER does.   


{{COMMENTS}
See 1AFTER.  And notice that this filtered trace will contain
enough information to make a disassembled trace sensible--
sometimes.

~8BIT`no parameters       RARELY USED

Selects 8-bit mode for trace display and memory emulation and for
PROM burning and reading.


{{USAGE}
 You will probably not use this command.  It sets up the UniLab
to work with processors that make use of 8 bit data.  If you have
purchased a disassembler, then either this command or 16BIT has
been "built-in" to your software.
  

{{COMMENTS}
Use the 24 pin ROM cable with this command.  8BIT is one word,
with no space between the number 8 and the rest of the command.
~9.6K`no parameters       RARELY USED

Changes baud rate of serial port to 9.6 K baud.  The default is
19.2 K baud. 

{{USAGE}
Use to lower the baud rate for communication to the UniLab. Be
certain to toggle the switch in the UniLab as well.  The switch
is inside the UniLab case, toward the back of the board, next to
the plug-in for the connection to the host computer. 

See also 19.2K, for restoring the default.  

You must SAVE-SYS to make the change permanent.

~:`no parameters       Macro Sys
  
The colon character starts a macro definition.  The word that
follows the colon is the name of the macro.


{{USAGE}
Once a macro has been defined, you can execute any lengthy series
of commands with a single word.  See Appendix F for further
information.  See also BPEX.

{{WHAT A MACRO IS}
A macro is a command that you create out of previously defined
commands.

For example, 

{{: LOADUP     0 TO 3FFF BINLOAD A:MYPROG ;}

creates a macro called LOADUP, which uses the previously defined
UniLab command BINLOAD.

LOADUP will always load from a file on drive A: called myprog. 
You can see how this would be easier than using BINLOAD every
time you wanted to load this file. 

{{HOW TO WRITE MACROS}
A macro definition begins with a colon and ends with a semicolon
(;).  The first word after the : is the name of the macro, and
all the other words are the definition of it.

There must be at least one space between the colon and the name
of the macro, and at least one space between the last word and
the semicolon.    Like this:

{{: NAME  FIRSTWORD SECONDWORD VALUE THIRDWORD ;}

{{FORTH}
When you define a macro, you are actually making use of the
programming language FORTH.   With this powerful language you can
define new words that make use of conditional statements,
looping, and more.  The best introduction to the language is Leo
Brodie's Starting FORTH. 



{{WHY MACROS}
The example below defines a macro called READRAM.  After the new
word has been defined, you would just type in READRAM every time
you want to set up the trigger specification that shows only the
cycles that read from the address range 1000 to 1FFF.  This will
save you a lot of keystrokes.


{{EXAMPLE

:  READRAM  ONLY READ 1OOO TO 1FFF ADR S ; }   
defines a macro called READRAM.

{{COMMENTS}
 Whenever the word immediately following : is entered the result
is the same as if the rest of the words up
to ; were entered.  After typing in the example above, the word
READRAM will have the same effect as entering " ONLY READ 1000 TO
1FFF ADR S ."  To preserve the macro definition, you must
SAVE-SYS before leaving the UniLab program.

See also appendix F.
~;`no parameters       Macro Sys
     
Ends a macro definition started by : .

~<TST>`<value> ' <TST> !       Macro Sys

Setting this constant to 1 will turn off the output of some
messages and will leave on the stack many results which are,
normally, printed out.

{{USAGE}
Use during testing procedures, or for sophisticated macros.  When
<TST> is set to one, such words as MM? will leave their results
on the stack, rather than printing them out.

Remember to set <TST> back to zero when you are through.


{{EXAMPLE

: NEWMM?  ( addr--val) 1 ' <TST> !  MM? 0 ' <TST> ! ;}
This macro will act the same as MM?, except it will leave the
word value it finds on the stack rather than printing it out.

~=BC`<word> =BC

Changes the contents of the BC register to n.


{{USAGE}
An example of the type of register control command available with
a DEBUG package.  This command addresses the Z-80 internal
register BC.  Consult the Target Application Note for your
processor-specific software. 


{{EXAMPLE

1234  =BC }
               puts 1234 in the BC register.


{{COMMENTS}
You can use the register commands only after DEBUG has gained
control of your microprocessor.  See NMI or RB for more
information on debug control.  

This is a typical register changing instruction format.  A
similar command is provided for each of the processors internal
registers (except SP).  No space appears between the  =  and the
register name. 

~=EMSEG`<hex digit> =EMSEG       RARELY USED

Sets A16-A19 context for subsequent EMENABLE statement(s).
Determines which 64K "bank" of memory the emulated ROM will be
in.

{{YOU PROBABLY DON'T NEED TO BOTHER}
This value must be set properly, or the UniLab will not put the
program opcodes onto the target system bus.  This variable is
already set properly for each disassembler/DEBUG software
package.  

{{WHY IT MIGHT MATTER}
Though the upper 4 bits of our 20-bit address bus are meaningful
only with processors that can address more than 64K of memory,
=EMSEG must always be set.  

On some microprocessors, those four lines are floating high, on
other mp's several of the lines are pulled low.

{{HOW IT WORKS}
This command only sets a variable.  EMENABLE is the command that
actually enables memory.  

{{WHEN IT MATTERS}
The UniLab looks at the upper 4 bits of address (A16 through A19)
during fetch and read cycles, to determine whether your
microprocessor wants to fetch an instruction from emulation ROM. 
If the upper 4 bits that the UniLab sees don't match the =EMSEG
specification, then the UniLab will not respond to the mp's
request.

Use ESTAT to see how this command effects the settings of
emulated memory.


{{EXAMPLES

7  =EMSEG}
   sets A19 to 0 and A16, A17, and A18 to one.

~=HISTORY`<hex# of Kbytes> =HISTORY

Selects the size of the screen history saved during each session
with the UniLab.

{{USAGE}
Allows you to change the amount of host RAM dedicated to saving
information that scrolls off the top of the screen.  The maximum
is hexadecimal 3C Kbytes (decimal 60).

The new setting will not take effect until you SAVE-SYS, exit
from the UniLab software, and start it up again.

Use ?FREE to find out how much is allocated right now.

{{WHY CHANGE}
You might want to have a longer history, or you might want to
free up some of the host RAM for other purposes.


{{EXAMPLE

3C =HISTORY}
allocates the maximum space to the line history.

~=MBASE`<n> =MBASE          F8

Selects number base for the trace display of the MISC inputs to
the UniLab,  M0 through M7.

{{USAGE}
The miscellaneous inputs (MISC) to the UniLab usually get
displayed in binary format.  This format allows you to easily
tell which MISC inputs are receiving a high signal, and which are
receiving a low.  

This command also changes the number base for the HDATA column
for 8 bit processors.

However, you might have an application for these inputs, such as
reading the data from onboard RAM, where a hex or decimal display
would be more useful. 

Normally you will use the MODE panel (function key 8) when you
want to change this feature.  

The panel only toggles between binary and hex.


{{EXAMPLES

10  =MBASE}
hexadecimal display, the most space efficient

{8  =MBASE}
     selects octal display mode.

{A  =MBASE}
     selects decimal display mode.

{2  =MBASE}
     returns to binary display mode.


{{COMMENTS}
The MISC inputs can be connected to any signals you like. 

Notice that A, not 10, must be used to specify decimal ten.
~=OVERLAY`<address> =OVERLAY

Changes the address of the area in emulation ROM used by the
ORION DEBUG software.

{{USAGE}
When your software uses the memory reserved by the ORION DEBUG
software.  This command changes the location of both the overlay
and the reserved area.  Use function key CTRL-F3 to find the
current address of the reserved and overlay area.

You can instead disable the DEBUG features for completely
transparent operation.  See RSP'.

You must SAVE-SYS to make the change permanent.


{{EXAMPLES

2310  =OVERLAY}
Moves the reserved area to start at 2310, and puts the overlay
area above there.


{{COMMENTS}
The overlay area should not cross a 2K boundary.  Be careful when
changing its location.

~=SYMBOLS`<hex # of Kbytes> =SYMBOLS

Selects the amount of space allowed for symbol tables within the
UniLab software.

{{USAGE}
Allows you to change the amount of host RAM dedicated to storing
the symbol table. The maximum is hexadecimal 80 Kbytes (decimal
128).

The new setting will not take effect until you SAVE-SYS, exit
from the UniLab software and start it up again.

Use ?FREE to find out how much is allocated right now.

{{WHY CHANGE}
You might want to have a larger symbol table, or you might want
to free up some of the host RAM for other purposes.


{{EXAMPLE

80 =SYMBOLS}
make the symbol table the maximum possible size.  

~=WAIT`<time> =WAIT

Changes the number of milliseconds that the UniLab software will
wait between resetting the processor and checking for the
processor clock.

{{USAGE}
When you need a longer wait after reset.  The default value is
140 (hexadecimal).

You must SAVE-SYS to make the change permanent.


{{EXAMPLE

280  =WAIT}
Sets the wait time to double the default value.

~?FREE`no parameters

Displays the amount of host RAM allocated to the screen history
and to the symbol table.  Also shows how much host RAM is
currently free.

{{USAGE}
Find out how much you can increase the amount of space dedicated
to history or symbol table, or whether you need to reduce it. 
See =HISTORY and =SYMBOLS.

~ADR`<word> ADR
<word> TO <word> ADR

Sets up the trigger specification for analyzer inputs A0 through
A15.  (Sets trigger for A0 to A19 if five-digit address ends in a
period.)


{{USAGE}
Determines which 16 bit addresses the analyzer will trigger on. 
Can also trigger on 20-bit addresses.

With TO the trigger will occur on the address range from ADR1 to
ADR2.  

If NOT precedes the value(s) of the address, the UniLab will
trigger outside of the specified address or range of addresses.  

All previous entries to the address trigger spec are erased
unless you precede this spec with the word ALSO.

You can inadvertently produce "cross products" when making use of
ALSO with ADR.  See the fourth example below.


{{EXAMPLES

NORMT 1023 ADR S }
trigger on address 1023.  NORMT causes the trigger to appear at
the Top of the trace.  

{NOT 120 TO 455 ADR S }
trigger if address outside 120-455 range.

{12345. ADR S }
trigger on 20-bit address 12345.  The 1 will appear in right
digit of the CONT column.

{1200 ADR  ALSO 8 ADR}
sets the analyzer to trigger when the 
address is 1200 or 0008.  Because of cross products, will also
trigger on address 0000 and 1208.

~ADR?`no parameters

Displays random examples of the addresses seen on the bus--
approximately two every second.


{{USAGE}
This command displays two of the addresses that appear on the bus
each second.  A useful command for getting a rough-grained idea
of how the program behaves.

Terminate the display by pressing any key.  

{{EXAMPLE

ADR?}
This command is never used in combination with anything else.

{{COMMENTS}

Useful for monitoring program flow in a rough manner. For
example, it will be obvious to you if the target program gets
stuck in a loop. ADR? turns RESET mode off and sets up a trigger
spec of its own.  Be sure to use NORMx at the start of the first
trigger spec after using this word.
~AFTER`AFTER <qualifier specification>

Sets the stage for the description of a qualifying event. 
Qualifying events are bus states that must be seen before the
analyzer starts to search for the trigger.

{{USAGE}
When you have specified qualifying events, the UniLab will not
recognize the trigger until after the "qualifiers" have been
seen.

You can set up to three qualifying events.  Each qualifier spec
must start with AFTER.  

All the qualifiers must appear on the bus one immediately after
another, without intervening bus cycles.  However, the trigger
itself can appear anytime after all the qualifiers have been
satisfied.

You cannot use MISC inputs as qualifiers.

{{DELAYS AND REPETITIONS}
You can specify a minimum number of bus cycles after the time the
last qualifier is seen, before the UniLab starts looking for the
trigger.  See PCYCLES.  The default is 0 PCYCLES.

You can also specify a number of complete repetitions of the
sequence of qualifiers.  See PEVENTS.  The default is 1 PEVENTS.

                               Qualifier 3 <--------!
                                   !                !
                      (immediate)  !                !
                                   V                !
                               Qualifier 2         /!\
                                   !                ! (if PEVENTS
                      (immediate)  !                !    greater
                                   V                !    than 1)
                               Qualifier 1         /!\
                                   !                !
                                   V                !
                   (wait PCYCLES.  !                !
                    Default is 0.) !                !
                                   !---->------>----!
                                   !                
                                   V                
                                Trigger 
 (continued from previous page)

{{EXAMPLES

NORMT 100 ADR AFTER 535 ADR S }
will trigger on address 100 only after address 535 gets seen on
the bus.

{AFTER 3F DATA S }
You can add a second qualifying event-- which must occur earlier
than the first.  Now address 535 must be immediately preceded by
data 3F hex before UniLab will look for address 100 on the bus.

{NORMT 100 ADR   AFTER  535 ADR  AFTER  3F DATA  S }
a single statement with the same result as the two above.

{NORMT AFTER NOT 345 ADR AFTER 344 ADR S}
triggers if any address other than 345 follows immediately after
344.  By starting with AFTER we are able to describe two events
which must follow one another without intervening bus cycles.


{{COMMENTS}
Equivalent results can be obtained by using
<n> QUALIFIERS to set the number of qualifiers.  The four related
commands TRIG, Q1, Q2, and Q3 can then be used to set the various
triggers.  But AFTER is the more natural way to do it.

You will find Q1, etc., handy when you want to "change context"
to alter the description of an event that you though you had
completed.
~AHIST`no parameters            PPA

Address HISTogram invokes the optional Program Performance
Analyzer (PPA), which allows you to display the activity of your
target program in each of up to 15 user-specified address ranges.
See also MHIST and THIST.

{{USAGE}
Allows you to examine the performance of your software.  You can
find out where your program is spending most of its time.

Press F10 to exit from this menu-driven feature.

You must (only once) issue the command SOFT to enable this
optional feature.  SOFT performs a SAVE-SYS, and then causes an
exit to DOS.  The next time you call up the software, the PPA
will be enabled.

{{MENU DRIVEN}
You produce a histogram by first specifying the upper and lower
limits of each address "bin" that you want displayed, then
starting the display.

When you give the command AHIST you get the histogram screen with
the cursor positioned at the first bin.  You can then start
typing in the lower and upper limits of each bin.  Use return,
tab or an arrow key after you enter each number, to move to the
next entry field.

Press function key 1 (F1) to start displaying the histogram.

{{SAVE TO A FILE}
You can save the setup of a histogram as a file with the HSAVE
<file>.  Issue this command after you exit from the histogram.

You load the histogram back in with HLOAD <file>.  This command
also invokes the histogram.

{{EXAMPLE

AHIST}
This command is never used in combination with anything else.
~ALSO`no parameters

Used with both EMENABLE and with trigger specification commands. 
Prevents clearing of previous settings.

{{USAGE}
The trigger spec commands, CONT, ADR, DATA, HDATA, HADR, LADR and
MISC, normally cause the UniLab to trigger on the new conditions
instead of the old conditions.  By using ALSO, you can instruct
the UniLab to trigger on the old conditions OR the new
conditions.

The memory enable command, EMENABLE, normally enables only the
new settings of memory.  By using ALSO, you can enable both the
old range of memory and the new. 

You have to use ALSO for each new setting that you declare.  See
the second example below.

ALSO is not necessary when you want to trigger on several
different categories.  The UniLab will automatically AND together
the specifications in different categories.

You can inadvertently produce "cross products" when making use of
ALSO with ADR.  See ADR. 


{{EXAMPLES

12 DATA ALSO 34 DATA}
sets the analyzer to trigger on either 12 or 34 data (without the
ALSO only 34 data would remain set).

{10 DATA ALSO 5 DATA ALSO 3 DATA   1200 ADR  }
sets the analyzer to trigger when the 
data is 10 or 5 or 3 and  the address is 1200.

{0 TO 7FF EMENABLE   ALSO 2000 TO 2FFF EMENABLE}
enables two ranges of emulation ROM.

{{COMMENTS}
Applies only to the first EMENABLE or trigger spec command that
follows.  
~ALT-FKEY`<# of key> ALT-FKEY  <command>

Assigns a command to an ALTered function key.

{{USAGE}
Reassign the function keys on PCs and PC look-alikes. Use
ALT-FKEY? (or press F1 while holding down ALT) to find the
current assignments.
     
The function keys allow you to execute any command or string of
commands with a single keystroke.  The initial assignments
represent our best guess at what you will need.  But you might
want to change them.

To make your reassignments permanent, use        SAVE-SYS. 


{{EXAMPLE

2 ALT-FKEY WSIZE}
              assigns WSIZE to ALT-F2.


{{COMMENTS}
To execute a string of commands, define a macro first (using : )
and then assign the macro to the function key.  

See also FKEY, CTRL-FKEY, and SHIFT-FKEY.

~ALT-FKEY?`no parameters       ALT-F1

Displays the current assignments of the ALTered function keys.

{{USAGE}
Whenever you want to be reminded what command will be executed
when you press a function key while holding down the ALT key.

See ALT-FKEY to reassign the keys.
~ANY`ANY <input group>

Sets a trigger spec that will trigger on any value on the input
group.

{{USAGE}
Provides a way to "clear out" the trigger on any selection of
input groups.  This can sometimes save you the trouble of re-
entering a trigger spec.

This command is most appropriate after you have entered and used
a trigger spec, but now want to use a broader trigger spec.


{{EXAMPLE

ANY CONT }
     trigger when any value appears on the CONT input lines.  The
rest of the trigger spec remains unchanged.


{{COMMENTS}
The macro definition of this command:
             : ANY     0 TO FFFF ;
~AS`<addr> AS

An abbreviation for NORMT ADR S.


{{USAGE}
Defines an analyzer trigger spec, and starts the analyzer
working.  The trigger event appears near the top of the trace as
cycle zero.  A useful abbreviation-- saves you key strokes.  When
entering the most common trigger spec-- triggering on a code
address.

Will not work on ranges of addresses (with TO) or with NOT.


{{EXAMPLE

1234 AS  }
      triggers when address is 1234


{{COMMENTS}
The macro definition of this command:
             : AS NORMT ADR S ;
~ASC`no parameters       SHIFT-F4

Displays the handy reference ASCII table.

{{USAGE}
Shows each character, along with its decimal and hex value. 


{{EXAMPLE

ASC}
          This command is never used in combination with anything
else.


{{COMMENTS}
This is a bonus feature provided to save you the trouble of
hunting for a printed ASCII table.  

~ASEG`<hex digit> ASEG       RARELY USED

Sets a trigger spec on address bits A16-A19.  ASEG cannot be used
with NOT, ALSO, or TO.

{{USAGE}
Normally, you set a trigger address with ADR, either a 16 bit or
20-bit address.  This command allows you to set a trigger on the
upper 4 bits of the 20 bit address.  See =EMSEG for a longer
discussion of the addressing scheme of the UniLab.


{{EXAMPLES

5  ASEG}
          requires a hex value of 5 on A16-A19 for trigger.


{{COMMENTS}
Normally useful only if you have over 64K of memory in your
target system.  Even then, a better way to define a trigger on a
5-digit address is just to enter the 5-digit address ending in a
period followed by ADR.  

The command "n ASEG" has the same effect as "F MASK n CONT." 

~ASM`<address> ASM <instruction>

Invokes the processor-specific line-by-line assembler. 

{{USAGE}
Patch assembly language code to the given address in emulation
ROM.  Allows you to overwrite locations in the copy of your
target program residing in the UniLab's emulation ROM, so that
you can quickly fix bugs when you find them.  The assembler
writes over memory-- it does not insert instructions.

If you do not include the address, ASM will use the current value
stored by the ORG command.  

{{ASSEMBLING MULTIPLE INSTRUCTIONS}
If you do not include an assembly language instruction, then ASM
will give you as a prompt the address to which it is assembling,
and wait for you to give it an instruction followed by a carriage
return.   

The assembler will continue to prompt you with an address and
patch assembled code into memory, until you feed a blank line
(press return on an empty line).

{{CONVENTIONS}
The line-by-line assembler will only accept assembly language
instructions, not ORIGIN statements or EQU statements.  (You
should use the UniLab command IS to define symbols.)  

Only one instruction per line.

The normal conventions of assembly language apply.  For example,
at least one space between the instruction and the operands.

The Target Application Note contains a section listing the
instruction set recognized by the assembler. 




{{EXAMPLES

0 ASM  LD SP,3000}
alters the first instruction of the LTARG program of the Z80
package.

{100 ASM}
invokes the assembler, starting at address 100.                  
The assembler will prompt you with that same                     
address, and wait for you to enter an assembly                   
language instruction.
~ASM-FILE`<addr> <start screen> <end screen> ASM-FILE

Invokes a version of the line-by-line assembler that assembles
code contained on the screens of a FORTH file.

{{USAGE}
A way to make large patches to your program, or to write
prototype code without leaving the UniLab environment-- or just
to write a few lines that you will want to be able to edit and
re-enter.

ASM-FILE follows the same conventions as ASM.

You can include comments on a screen by putting a semicolon (;)
on a line.  The assembler will ignore everything after the
semicolon on that line.  The semicolon must be the first
character on the line, or be preceded by at least one space.

{{FORTH FILES AND THE EDITOR}
If you only have a few lines of code, you can use the screen that
MEMO puts you into, and the two following (screens 1D through
1F).  See the entry for MEMO to get a few pointers on using the
FORTH screen editor.

{{OPENING A NEW FILE}
You will want to put the code into a file of its own if you have
many lines of code, or if you want a more convenient way to
archive the code.  You must make a MACRO system before you can
use the file commands.

First close the current file (UniLab.SCR) with the command CLOSE.



Next create a new file with OPEN-NEW <file name>, and determine
its size with <# of screens> SCREENS   (1K allocated per screen).

Use the command <screen #> EDIT to get into the file.  Don't make
use of screen zero.

You will then be able to use ASM-FILE to assemble the code stored
in your new file.   

When you are done with assembling, use OPEN UNILAB.SCR to close
your file and re-open the UniLab.SCR file.  If you don't do this,
then some of the on-line help facilities and error messages will
not work.



{{EXAMPLES

1200  1D 1F  ASM-FILE}
loads assembly code, starting at address 1200, from screens 1D
through 1F of the currently opened FORTH file.

{1 4 ASM-FILE}
loads code from screens 1 through 4, starting at the current
value of ORG.

~AUX1`no parameters       RARELY USED

Tells the host computer to look for the UniLab on serial port 1.
This is the normal default condition.

~AUX2`no parameters       RARELY USED

Tells the host computer to look for the UniLab on serial port 2. 
Only use this command if you have the UniLab connected to serial
port 2.
~B#`B# <binary number>       RARELY USED

Interprets the number following as a binary number.

{{USAGE}
Useful when you want to input a number as a binary-- saves time
with pencil and paper.  Quick, what is the hex value of a number
with 1 at locations 0, 3, 7, 9 and 10?  Let the computer do that
work for you.


{{EXAMPLES

B#  0101010001001 }
has the same effect as entering 0A89H
 
{NORMT  B#  1111110  MISC  S }
will trigger when the MISC inputs are 11111110  

 
{{COMMENTS}
Changes the base to binary, just for the next number. Allows
entering numbers in binary format, just as D# allows decimal
format.
~B.`<hex number>  B.       RARELY USED

Displays the hex number as a binary number.

{{USAGE}
When you want to find out the binary equivalent of a hex number,
saves you time with pencil and paper.  


{{EXAMPLE

A89 B.} 
displays the binary equivalent of A89, which is 0101010001001.
~BINLOAD`<from addr> <to addr> BINLOAD <filename>

Loads a binary file from disk into emulation memory.  Prompts you
for the name of the file if you don't include it on the command
line.


{{USAGE}
Starts loading a binary file into the from addr.  Stops loading
at the to addr, or when end of file is reached.  The binary file
should contain a program.  Can be used to load the product of a
cross compiler into emulation memory.

This command fully supports DOS pathnames.

You can save a program to a file with BINSAVE.


{{EXAMPLE

0 400 BINLOAD \ASM\MAIN.BIN}
loads a binary DOS file,  starting at location 0 and ending at
location 400.


{{COMMENTS}
Loads exact binary contents of file until DOS indicates end of
file,  or the "to address" is reached.  If you don't know the
ending address, you can just enter FFFF as toadr and loading will
stop on end-of-file.  

As with all memory writing commands, don't write into your stack
area when loading into RAM.

Use with .COM,.BIN, or .TSK files.  See HEXLOAD for Intel Hex
files.

The Orion software can load to target RAM as well.  See NMI and
RB.
~BINSAVE`<1st addr> <2nd addr> BINSAVE <file name>

Saves the specified section of memory as a file.  Prompts you for
the file name if you do not include it.


{{USAGE}
This command saves the program memory to disk.  Saves everything
in memory between the first address and the second address. 

This command fully supports DOS pathnames.


{{EXAMPLE

100 4FF BINSAVE}
     saves target locations 100 - 4FF.


{{COMMENTS}
Saves exact binary contents of a range of target memory as a
named file.  This file can later be re-loaded with the BINLOAD
command.  

Can save from target RAM as well. See NMI and RB.






~BPEX`BPEX <macro name>       Macro Sys

Executes the specified macro at each breakpoint, after the
register display.

{{USAGE}
Allows you to automatically execute any command or group of
commands, at every breakpoint. You must first define a macro, or
use one of the pre-defined Orion command words.  

BPEX will not accept a string of commands, only the first word
that follows.  This means that only certain commands are
suitable-- those that require no parameters.   In the example
below, we first write a macro that requires no parameters, called
SEE-RAM.  Notice that SEE-RAM makes a call to MDUMP, which does
require parameters.

See : for more info on macros.                                   

{{TURN IT OFF}
To turn off the automatic execution use BPEX NOOP.


{{EXAMPLES

:  SEE-RAM  8000 8080 MDUMP  ;}
defines a macro called SEE-RAM which dumps out 80 memory
locations.

{BPEX SEE-RAM}
executes your macro at every subsequent breakpoint.


{{COMMENTS}
Available only with DEBUG packages.  Useful if, for example, you
want to watch a memory window as you single step through the
program.  
~BPEX2`BPEX2 <macro name>       Macro Sys

Execute a second macro at each breakpoint. See BPEX. 
~BYE`no parameters

Exits from UniLab program.

{{USAGE}
To return to DOS.  Use SAVE-SYS first, if you want to save the
current state of the system.  

Use DOS instead if you want to execute just a few DOS commands
and then return to the UniLab program.


{{EXAMPLE

BYE}
     This command never used in combination with anything else. 





~CATALOG`no parameters

Displays a directory of all the available pinouts-- the proper
cable hook-ups for each microprocessor. 

{{USAGE}
Once this word is entered, any of the listed pinouts can be
displayed on the screen.  

This word "opens" the pinout library.   It closes again as soon
as you enter another command.

Until you use this command, the only pinout diagram available is
that of the mp you are using.  You get that with the command
PINOUT.

~CKSUM`<from addr> <to addr>  CKSUM     
Calculates the checksum for a given range of memory.  Useful for
error-checking.


{{USAGE}
A good way to make a PROM easy to check for burn-in errors, or
corrupted locations.  Allows you to record the checksum of your
program-- or better yet, make the checksum equal to zero.


{{EXAMPLE
     
     800 FFF CKSUM }  
prints a 16-bit checksum for the data in addresses 800-FFF

{{COMMENTS}
You may want to patch the complement of this value into your
PROM.   You can produce a PROM with a checksum of zero, using the
following method, which sacrifices only two bytes.
  
First store zero where the checksum will be 
(0 FFE MM! in the above example). Second, find the checksum,
using CKSUM.  Lastly, patch in the complement of the sum.  

For example, if the sum is 1234, then use the command -1234 FFE
MM!.  The resulting PROM will have a checksum of 0. 

~CLEAR`no parameters       RARELY USED

Clears the screen before performing a PgUp.  Use with some of the
older color monitor cards, that will otherwise flicker when you
use PgUp.
~CLEAR'`no parameters       RARELY USED

The normal default condition-- the screen is not cleared before a
PgUp is executed.   Use only to restore the default condition
after executing a CLEAR.
~CLRMBP`no parameters

Clears all multiple breakpoints.

{{USAGE}
Use to wipe the slate clean, and start out setting multiple
breakpoints again.  SMBP sets the breakpoints.


    {{EXAMPLE

CLRMBP}
          This command never used in combination with anything
else.


{{COMMENTS}
Use to clear all the numbered breakpoints which you set with SMBP
and can clear one at a time with  RMBP.

~CLRSYM`no parameters

Clears out the current symbol table.

{{USAGE}
When you want to get rid of the symbols that you have defined for
your program.  It's a good idea to first save the symbols, just
in case you decide you want those symbols after all.  See
SYMSAVE.

The symbol table also gets cleared by SYMFILE and SYMLOAD before
they load in the new symbols.  SYMFILE+ adds to the existing
symbol table.

Unless you save the symbols, you cannot recover them later.  You
could instead use SYMB', which turns off the symbol table without
erasing it.  


{{EXAMPLE

CLRSYM}
          This command never used in combination with anything
else.


{{COMMENTS}
You might want to clear out the table before loading in a new one
from a file.  See SYMFILE and SYMLOAD.






~COLOR`no parameters       RARELY USED

Displays in color.  Only has an effect with a color monitor.

{{USAGE}
Turns on color display.

You have to save the system afterward, if you want the UniLab
program to start up with color display. 

{{CHANGING COLORS}
Use the UniLab command SET-COLOR, which shows you what the new
settings are as you change them.

You will have to save the system with SAVE-SYS if you want to
preserve the new colors.


{{EXAMPLES

COLOR}
This command never used in combination with anything else. 

~COM1`no parameters

Enables dumb terminal emulation mode, using serial communications
port 1 of your personal computer.  This is the port normally used
by the UniLab.

{{USAGE}
Allows you to use your PC as a dumb terminal while within the
UniLab software.  Press the ESCape key to exit.

{{COMMUNICATION SETTINGS}
The default settings are:
300 baud
8 bits, 2 stop bits, no parity.

{{CHANGING SETTINGS}
You can change these settings by changing the values stored in
two constants, BR2 (Baud Rate) and LCR2 (Line Control Register:
bits per character, etc.).

Put the value 60 into BR2 to change to 1200 baud:

60 ' BR2 !

You may miss characters at 1200 baud, due to the screen scroll
times.  Put a 180 into BR2  to change back to 300 baud.  

You can change to 7 bits, 2 stop bits with:
6 ' LCR2 !

TABLE OF SETTINGS
# bits     parity     #stop bits      value to store at LCR2
7          None         1               2
7          None         2               6
7          Odd          1               A
7          Odd          2               E
7          Even         1              1A
7          Even         2              1E
8          None         1               3
8          None         2               7
8          Odd          1               B
8          Odd          2               F
8          Even         1              1B
8          Even         2              1F
~COM2`no parameters

Enables dumb terminal emulation mode, using serial communications
port 2 of your personal computer. See the entry for COM1 for
details.

{{USAGE}
Allows you to use your PC as a dumb terminal while within the
UniLab software.  Press the ESCape key to exit.

Change the communications settings the exact same way that you do
for COM1.
~CONT`<byte>  CONT        RARELY USED
<byte> TO <byte>  CONT
   <byte> MASK <byte>  CONT   

Sets up the analyzer trigger spec for the CONT inputs (control
lines C4 - C7,  and A16 - A19).

{{USAGE}
The CONT input lines actually represent two different types of
information.  The upper four bits represent the processor cycle
type.  The lower four bits come from the four highest address
lines, A16 through A19.

When you precede it with one number, CONT causes the UniLab to
trigger when the inputs equal that number.  When you use TO the
UniLab triggers on any value from m to n.  NOT causes the UniLab
to trigger when the value falls outside of the specified range or
value. 

You can use k MASK l to examine any subset of the 8 input lines. 
See Comments below for more details.

Unless you use ALSO the previous trigger spec gets cleared out.


{{EXAMPLES

B# 00011111 CONT}
requires C7-C5 = 0, C4 & A19-A16 = 1.

{70 TO 7F CONT}
requires C7=0 and C6-C4 = 1, A19-A16 any value.

{F MASK 3 CONT   }
requires A19 & A18 = 0, A17 & A16 = 1, C7-C4 any value. 








{{COMMENTS}
The low four bits of the CONT lines refer  to the highest four
bits of the address-- the same segment address bits set by
=EMSEG.

When you use the command k MASK l CONT, the value of k determines
which bits the UniLab will examine-- the bits with a value of
one.  The l then indicates the value those lines must have before
trigger occurs.  

For example, F0 MASK AF tells the UniLab to only look at the
upper 4 bits of the CONT lines.  The AF tells the UniLab to
trigger when bits 7 and 5 are high while bits 6 and 4 are low. 
The UniLab will "not care" about the value of the lower four
bits.
~CONTROL`no parameters       RARELY USED

Used before FILTER to set up a filter spec based only on the CONT
inputs.

{{USAGE -- RARELY USED}
You will probably never use this command.  Triggers on the full
specification, but filters based only on the 8 bits of the CONT
inputs.  

The filter mechanism of the UniLab gets turned on for you by the
xAFTER macros.  Those commands set the filter to MISC' FILTER,
which allows  you to set up a trigger spec based on all inputs
except for the MISCellaneous wires.

See also HDAT, MISC', and NO.

{{THE CONT INPUTS}
The upper four bits identify processor cycle type, while the
lower four bits identify the address bits A19-A16.

This command makes it possible to filter on cycle type and on
memory segments.  


{{EXAMPLE

NORMT CONTROL FILTER WRITE   1200 ADR  A7 DEVENTS S }
triggers on 1200 address, and then records only writes.  You have
to use DEVENTS to get a trace buffer full of the event you are
filtering on.

~CTRL-FKEY`<# of key> CTRL-FKEY  <command>

Assigns a command to a function key pressed while the CTRL key is
held down.

{{USAGE}
Reassign the function keys on PCs and PC look-alikes.  Use
CTRL-FKEY? (or CTRL-F1) to find the current assignments.
     
The function keys allow you to execute any command or string of
commands with a single keystroke.  The initial assignments
represent our best guess at what you will need.  But you might
want to change them.

To make your reassignments permanent, use        SAVE-SYS. 


{{EXAMPLE

5 CTRL-FKEY DOS}
assigns DOS to CTRL-F5.


{{COMMENTS}
To execute a string of commands, define a macro first (using : )
and then assign the macro to the function key.  

See also FKEY, ALT-FKEY, and SHIFT-FKEY.

~CTRL-FKEY?`no parameters       CTRL-F1

Displays the current assignments of the ConTroLled function keys.

{{USAGE}
Whenever you want to be reminded what command will be executed
when you press a function key while holding down the CTRL key.

See CTRL-FKEY to reassign the keys.
~CYCLES?`<from addr> <to addr>  CYCLES?

Counts the number of bus cycles between two addresses.

{{USAGE}
Can use to count the number of bus cycles in a loop, as in the
first example below, or the "distance" between two addresses.  

{{BUS CYCLE COUNT}
Not the number of machine cycles, nor the number of instructions
fetched, but instead the number of reads and writes that occur
between one command and another.  The read could be instruction
fetches, or could be data fetches.


{{EXAMPLES


123 CYCLES?}
counts cycles between two occurrences of the address 123.

{123 456 CYCLES? }
counts cycles between address 123 and address 456. 
{12300. 12450. CYCLES? }
counts cycles between address 12300 and address 12450.


{{COMMENTS}
Useful for checking quickly whether a loop works as you intended.
CYCLES? makes its own trigger spec, so you will have to start
fresh on your trigger after using this command. Use one of the
NORMx commands to clear out the trigger spec set by CYCLES?.

When specifying a five-digit address, the . which designates a
five-digit address must be used with both addresses.

~D#`D# <decimal number>       RARELY USED

Treats the number that follows as a decimal value, rather than as
a hexadecimal, which is the default.

{{USAGE}
Saves you the trouble of converting the number by hand or with a
calculator.


{{EXAMPLES

D# 16 ADR}
equivalent to entering "10 ADR".

{D# 32 .}
will display 20 (the hex equivalent of 32 decimal).

{D# 135 B.}
converts a number from decimal to binary.

{D# 1000 MS
will pause 1 second.


{{COMMENTS}

See also B# for entering binary numbers.

~DASM`no parameters       F8

Enables the trace disassembler.

{{USAGE}
Turns on the translation of machine code into assembly language
mnemonics.  You will usually want to keep this on, only turning
it off for special applications such as xAFTER.  To turn off the
disassembler, use DASM'.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.


{{EXAMPLE

DASM}
selects disassembled mode for trace display.  


{{COMMENTS}
Works only if you have an optional disassembler installed.







~DASM'`no parameters       F8

Disables the trace disassembler.

{{USAGE}
Turns off the translation of hexadecimal machine codes into
assembly language mnemonics.  See DASM above for more details.

Typically you will use the MODE panel (function key 8) when you
want to change this feature.


{{EXAMPLE

DASM'}selects hex mode for trace display.
~DATA`<byte> DATA
<byte> TO <byte> DATA
   <byte> MASK <byte> DATA

Changes the analyzer trigger for the DATA inputs (D0 to D7).

{{THE DATA INPUTS:}
The UniLab gets both the address and the data from the bus during
each memory read and write.  The "data" that appears on the bus
could be either a value or a machine code instruction.  See
COMMENTS below for information on triggering on a 16-bit data
bus.

{{USAGE}
The simplest use sets up a trigger for a single data value.  The
UniLab will search for the byte value, and trigger when it sees
that hex number on the bus as data.  See the first example below.

{{RANGES OF DATA:}
TO lets you set up a trigger on any data between two byte values,
inclusive.   See the second example below. 
{{NOT}
NOT causes the UniLab to trigger when the value falls outside the
specified range or value.    

{{MASKING}
You can use k MASK l DATA to examine any subset of the 8 data
lines.  The high bits of k mark which bits will be examined,
while the bit configuration of byte l indicates the values the
lines must have for a trigger to occur.

For example, 80 MASK FF DATA selects only the highest data bit
for examination (with binary value 1000 0000). The UniLab would
trigger when this bit has a high value.  The instruction 80 MASK
80 DATA would have the same effect.





( DATA continued on next page)                      
(continued from previous page)

{{EXAMPLES

NORMT 12 DATA S }
after clearing all previous settings with NORMT, sets up a
trigger for data input 12, and then uses S to start the analyzer.

{12 TO 34 DATA }
requires data value between 12 and 34 hex.

{F0 MASK 30 DATA }
sets a trigger based only on the four highest bits of data. 
UniLab will look for a 3 on those lines. 
{23 DATA ALSO 45 DATA}
sets a trigger on cycles where data is either 23 or 45 hex. 


{{COMMENTS}
The data inputs (D0-D7) are normally connected via the emulator
cable at the ROM socket.  On 16-bit processors DATA is only half
of the data bus, while HDATA is the other half.  

If you need to use a large number of ALSO terms, then see NDATA.

~DCYCLES`<number of cycles> DCYCLES

Sets number of cycles the UniLab will continue to record after
the trigger.

{{USAGE}
When the UniLab sees the trigger event on the target board, it
consults the delay cycles variable to determine how many more
cycles to record.  Each time a new cycle enters the trace buffer
you lose the oldest recorded cycle.  After the UniLab records the
specified number of cycles, it shows the trace buffer on the
screen.

{{WHY YOU DON'T NEED TO BOTHER}
This command gets executed by a number of other commands.  NORMT,
for example, sets the delay value to A0 (160 decimal).  That
delay count puts the trigger event near the top of the trace
buffer, after the ten cycles that came just before it. 

{{WHY YOU MIGHT WANT TO}
You might want to see the trace starting 260 cycles after a known
event-- perhaps you don't know where the program ends up at that
time.  The DCYCLES command will do the job perfectly.


{{EXAMPLE

104 DCYCLES}
selects 104 (hex) delay cycles (260 decimal)


{{COMMENTS}
NORMT, NORMM, and NORMB select A0, 55, and 4 DCYCLES
respectively.  S+ increases the number of delay cycles by A6, so
you can see what happens after the end of the current  trace.

The maximum possible delay count is FFFF.  
           
~DEFW`no parameters       F5

Returns the window to the size last set with WSIZE, or to the
default if you have not changed the window size.

{{USAGE}
The help screens readjust the window size, to make the lower
window as large as possible without overwriting the information
in the upper window.  After you have used a help screen, you
might want to return the DEFault Window size.  Just press
Function key 5.

{{SAVING A DEFAULT}
You can use SAVE-SYS to save all the current settings at any
time.  


{{EXAMPLES

DEFW}
This command never used in combination with anything else. 

~DM`<start address> <count> DM 

Disassembles <count> number of lines, starting at the given
address.
     
{{USAGE}
A very useful tool for examination of memory.  Allows you to see
what instructions are in emulation memory and in RAM as well.  
See also DN.  

Can give misleading results if you give an address that is not
the first address of an opcode, but even then will generally come
"into sync" after a few instructions.


{{EXAMPLE

100 10 DM}
disassembles 10 lines starting at address 100


{{COMMENTS}
Normally disassembles from ROM.  Works only if you have an
optional disassembler.  Can disassemble from target RAM as well.
See NMI and RB.

~DMBP`no parameters 

Displays the settings of all eight multiple breakpoints.

{{USAGE}
When you forget the settings of your multiple breakpoints.  
Automatically executed whenever you set one of the 8 multiple
breakpoints with SMBP.


{{EXAMPLES

DMBP}
This command never used in combination with anything else.

~DN`<start address> DN

Disassembles from memory into the right-hand side of current
window.  Displays one instruction per line and fills the right
hand window.

{{USAGE}
When you want to keep the disassembly from memory on the screen
while preforming other operations.  This command is similar to
DM, except that it writes into a portion of the screen that is
only used for this feature.  

The disassembly produced by DN does not scroll off the screen. 
You can get rid of it by using F2 to get out rid of the split
screen and then scrolling the screen (or, if currently looking at
an un-split screen, press F2 twice).


{{EXAMPLES

20F0 DN}
Fills the right side of the current window with assembly language
code, starting from address 20F0.

~DOS`DOS  <DOS command>

Execute a DOS command from the UniLab program.  
Or, use with no parameters to exit to DOS temporarily.  Return to
UniLab program by typing EXIT. 

{{USAGE}
When you forget the name of the file where you stored that
program, or have any other reason to use the DOS utilities.  You
can either execute a single command, or you can go to DOS and
execute a series of commands.

If you go to DOS, you can re-enter the UniLab program.  Return to
the UniLab program by typing EXIT at the DOS prompt (A> or B> or
C>).  

If you use BYE to exit the UniLab program, you have to start it
up again by typing ULxx at the DOS prompt. 


{{EXAMPLES

DOS DIR /w}
Executes the DOS command "DIR /w."

{DOS}
Allows you to execute any series of DOS commands, then return to
the UniLab program.

{DOS  ASMB SOURCE.ASM OBJECT.BIN}
Assembles a new version of the program you are working on.

~EMCLR`no parameters

Tells the UniLab not to emulate ROM-- clears out the emulation
memory settings.

{{USAGE}
Commands the UniLab to not respond to any microprocessor requests
for data or instructions.  Use only when you want to run a
program from on-board ROM.

This word also disables the DEBUG features.   To turn them on
again for use with emulation ROM, use the SWI VECTOR choice on
the mode panel (F8) or RSP. 

Instead of running the program from a chip, you can use the PROM
READER MENU (F9 from the MAIN MENU) to read a program into
emulation memory from most ROM chips.


{{EXAMPLE

EMCLR }
This command never used in combination with anything else. 
~EMENABLE`<address> EMENABLE
         <from address> TO <to address> EMENABLE

Enables emulation memory, needed before you can load in a
program.  But first, set =EMSEG properly.

{{USAGE}
With a single address, enables the 2K memory region that includes
the given address.   =EMSEG just sets a variable in the host's
memory, while EMENABLE sends all the information to the UniLab.  


You can use SAVE-SYS to make the current settings permanent.

{{ON RANGES OF ADDRESSES}
TO enables the emulation memory from the beginning of the 2K
segment that includes the <from> address to the end of the 2K
segment that the <to> address is in.

{{CLEARING PREVIOUS SETTINGS}
Unless you precede emulation statement with ALSO, clears out
previous EMENABLE statements.

{{WATCH OUT}
When you try to emulate two separate ranges of memory, you can
accidentally overlay the two.  For example, with a 32K UniLab, 0
and 8000 reference the same memory location in the UniLab.

Of course, you can enable areas that do not overlap.  For
example, 0 TO 3FFF and also C000 TO FFFF would not conflict.


{{EXAMPLES

F  =EMSEG   O EMENABLE}
enables target addresses 0-7FF with A16-19 all set high.     

{0 TO 1FFF EMENABLE ALSO FFFF EMENABLE}
enables 0-1FFF and F800-FFFF

{F =EMSEG O EMENABLE ALSO E =EMSEG O EMENABLE}
enables locations FOOOO - F07FF and EOOOO - E07FF



{{COMMENTS}
The UniLab's enable logic first compares the A16-A19 value from
the most recent =EMSEG statement with the present bus address.  
Address inputs A11-A15 then get compared to an enable map, where
each entry corresponds to a 2K segment of memory.  When both the
segment and the 2K block are enabled, the UniLab accepts the
address, and puts its data on the bus. 
~ESTAT`no parameters

Tells you the current status of emulation memory.

{{USAGE}
When you want to find out what range of addresses is currently
enabled.


{{EXAMPLES

ESTAT}
This command never used in combination with anything else. 
~EVENTS?`no parameters

Starts the analyzer and counts occurrences of the currently
defined trigger event.

{{USAGE}
Useful for monitoring occurrences that you don't need a trace of.

An excellent way to see whether the program does what it should. 
If the program messes up spectacularly, or performs flawlessly,
then this command will show you that.  

Otherwise, you're left in the dark.


{{EXAMPLES

NORMT 123 ADR EVENTS?}
counts occurrences of address 123.

{NORMT 123 ADR FF DATA EVENTS?}
counts occurrences of data FF when the address is 123.

{NORMT   WRITE   78 TO FF DATA   1210 ADR   EVENTS?}
Counts the number of times a data value greater than 78 gets
written to location 1210.

{{COMMENTS}
You can also count such things as error conditions or system
usage. 

You can use this command if you want to sync a scope on the
UniLab's test point output.

~FETCH`no parameters

Tells the UniLab to look for trigger event only during fetch
cycles.

{{USAGE}
To search for a particular opcode.  After you give it this
command, the UniLab will not look for the trigger event during
reads or writes.

This command is not available on all processors.  

This command is used as part of a trigger spec, as shown in the
examples below.


{{EXAMPLES

NORMT FETCH 120 ADR S}
triggers when the program fetches from address 120.

{NORMT  FETCH  NOT 0 TO 7FF ADR  S}
triggers if the program tries to fetch an instruction from
outside the 0 to 7FF range.


{{COMMENTS}
This command, loaded with the disassembler, specifies a range of
CONT values corresponding to fetch cycles.
~FILTER`no parameters       RARELY USED

Selects trace filtering mode, according to previous 
word:  CONTROL, HDAT, MISC' or NO.

{{WHY YOU DON'T NEED TO BOTHER}
For most filtering of the trace, you will use commands such as
ONLY or xAFTER.  These words automatically select the MISC'
filtering mode for you.  The NORMx words turn off filtering.

You can use this command to set up a filter spec that is
different from your trigger spec.  This is sometimes a very
useful thing to be able to do.
                                                                 

{{EXAMPLE

NORMT  CONTROL FILTER READ 1200 ADR  A7 DEVENTS  S}
triggers when the processor reads from address 1200-- then
produces a filtered trace of the A7 (hex) read cycles that occur
after that.


{{COMMENTS}
You would want to bother when inventing your own filtering
command.
~FKEY`<# of key> FKEY  <command>

Assigns a command to a function key. 

{{USAGE}
Reassign the function keys on PCs and PC look-alikes.  Use FKEY?
(or F1) to find the current assignments.
     
The function keys allow you to execute any command or string of
commands with a single keystroke.  The initial assignments
represent our best guess at what you will need.  But you might
want to change them.

You have to use "A" (hexadecimal) as the number to assign a
command to F10.

To make your reassignments permanent, use        SAVE-SYS. 


{{EXAMPLE

2 FKEY STARTUP }
          assigns STARTUP to the F9 key.


{{COMMENTS}
If you find yourself performing some one action repeatedly, you
can save time by making it into a macro and then assigning it to
a function key.  For example
{{: DUMP100   0 100 MDUMP  ;
{{6 FKEY DUMP100}
will allow you to dump locations 0 to 100 by pressing function
key 6.

See also ALT-FKEY, CTRL-FKEY, and SHIFT-FKEY.

~FKEY?`no parameters       F1

Displays the current function key assignments.

{{USAGE}
Whenever you want to be reminded what pressing a function key
will do for you.

See FKEY to reassign the keys.


{{EXAMPLES

FKEY? }
This command never used in combination with anything else. 

~G`<address> G

Goes to the indicated address.  Exits DEBUG control, lets the
target run.

{{USAGE}
After you have set a breakpoint, and want to release debug
control and let the target run.  G is one of several ways to do
this.

G just gets the target board going.  After that, you can enter a
trigger spec and restart the analyzer, or you can use one of the
"big picture" words: ADR?, SAMP, or NOW?.

You could instead use STARTUP to restart the analyzer and the
board at the same time.  Or use NORMx followed by a trigger
specification and S, to restart the analyzer and give you a trace
of the event that you describe. 


{{EXAMPLE

1030 G}
exits from debug control, and resumes the target program at
location 1030.


{{COMMENTS}
Appropriate if you have a DEBUG package and have established
control by entering RESET adr RB, or NMI.  You can return to any
point in the program you like, but debug control will be lost.  

Use GB if you wish to resume the program at an address different
from the one you are stopped at but with another breakpoint set.

~GB`<addr to go to> <bpoint addr> GB                
Goes to the first address, and starts executing code, with a
breakpoint set at the second address.

{{USAGE}
When you want to move around the program without losing debug
control.


{{EXAMPLES

1200 330 GB}
resumes the program at address 1200, with a breakpoint set at
330. 


{{COMMENTS}
Available if you have an DEBUG package and have established DEBUG
control. See RB to establish DEBUG control.

~GW`<address> GW

Goes to the indicated address and waits until the analyzer is
started.  Releases the target board from DEBUG control.

{{USAGE}
To continue the execution of the program, starting at the given
address, after a new trigger spec has been defined.

A rather specialized but very useful command.


{{EXAMPLE

1100 GW  NORMT 1200 ADR S}
Goes to address 1100 and waits for the analyzer to be started. 
The trigger spec command sets the analyzer to capture a trace
showing the code at address 1200.
~H>D`<hex number>  H>D       RARELY USED

Displays the decimal equivalent of a hex number.

{{USAGE}
Shows you the decimal equivalent-- compare this with D#, which
allows you to enter a decimal number that will then be used by
the next command.

This word is similar to B. which shows you the binary equivalent
of a hex number. 


{{EXAMPLE

10 H>D }
will cause "16" to be displayed.

{333 133 - H>D }
will display "512,"  which is the decimal equivalent of 333 minus
133 (hex).

~HADR`< byte >  HADR       RARELY USED
    < byte >  TO < byte >  HADR    
< byte >  MASK < byte >  HADR

Changes the analyzer trigger for the high-order byte of the 16-
bit address (A8-A15). 

{{THE ADDRESS INPUTS}
You should normally use ADR to set 16 or 20 bits at once, but
there are limits to the use of ALSO in combination with ADR.

The UniLab gets both the address and the data from the bus during
each bus cycle. The UniLab works with up to 20-bit addresses. 
You can change the trigger specification of the least significant
byte with LADR, the second byte with this command, and the high
four bytes with CONT or ASEG.  

{{USAGE}
You can use this trigger spec command in the same way you use
DATA, CONT, etc..  However, the most frequent use of this command
is to set up a trigger spec on the address lines that makes use
of many calls to ALSO. 


{{EXAMPLES

NORMT 12 HADR  ALSO 34 LADR  ALSO 10 LADR  ALSO 5 LADR}
sets up the analyzer to trigger on any of the  addresses 1234,
1210 or 1205.

   {{COMMENTS}
Makes it possible to treat the first two bytes of the address
separately.  LADR is the lower half.
~HDAT`HDAT FILTER       RARELY USED 

Used before FILTER to set up a filter spec based only on the high
byte of the DATA inputs (D8 - D15).

{{USAGE -- RARELY USED}
You will probably never use this command.  Triggers on the full
specification, but filters based only on the 8 bits D8 through
D15.  

The filter mechanism of the UniLab gets turned on for you by the
xAFTER macros.  Those commands set the filter to MISC' FILTER,
which allows  you to set up a trigger spec based on all inputs
except for the MISCellaneous wires.

See also CONTROL, MISC and NO.

{{THE HIGH DATA INPUTS}
These lines read from the high byte of the 16-bit data path of
16-bit processors.  On 8-bit processors, the lines can be left to
float, or be used to sense other logic signals on your target
board.

{{USAGE}
Used to show only the cycles that meet your description.  While
deciding whether to include the current cycle in a filtered
trace, the UniLab will check only these 8 bits of the 48 inputs.

A good way to look at all the bus cycles that have some specific
data value as the upper byte of data.


{{EXAMPLE

NORMT HDAT FILTER 80 TO FF HDATA 3410 ADR A7 DEVENTS S}
will give a trace showing only those cycles with D15 high,
starting with the bus cycle that has D15 high and address 3410. 
You have to use DEVENTS to get a trace full of the event you are
filtering on.
~HDATA`< byte > HDATA
 < byte >  TO  < byte > HDATA
    < byte >  MASK  < byte > HDATA
Changes the analyzer trigger for the high byte of 16-bit data
path (D8 through D15).   Spare inputs on 8-bit processors.

{{THE DATA INPUTS}
The UniLab gets both the address and the data from the bus during
each bus cycle.  The "data" that appears on the bus could be
either a value or a machine code instruction.  On 8-bit
processors the inputs D8 through D15 can be hooked up to anything
you like.

{{USAGE} 
The simplest use sets up a trigger for a single value on the high
order byte of the data inputs.  The UniLab will search for the
byte value, and trigger when it sees that hex number on the bus
as data.  

Note that just looking at the high order byte means the UniLab
doesn't care about the low order byte, and so it actually
searches for a range of values.  See the first example below.

To specify just one full 16 bit wide data value, you must use
both HDATA and DATA.

{{RANGES OF DATA}
TO lets you set up a trigger on any data between two byte values,
inclusive.   See the third example below. 

{{NOT}
NOT causes the UniLab to trigger when the value falls outside the
specified range or value.    

{{MASKING}
You can use <i> MASK <j> HDATA to examine any subset of the 8
most significant data lines.  The high bits of i mark which bits
will be examined, while the bit configuration of byte j indicates
the values the lines must have for a trigger to occur.

For example, 01 MASK FF HDATA selects only data bit D8 for
examination (with binary value 0000 0001). The UniLab would
trigger when this bit has a high value.  The instruction 01 MASK
01 HDATA would have the same effect.
( HDATA continued on next page)                      
(continued from previous page)

{{EXAMPLES

NORMT 12 HDATA S }
after clearing all previous settings with NORMT, sets up a
trigger for data input 12XX -- actually 1200 through 12FF-- then
uses S to start the analyzer.

{12 HDATA 80 DATA}
sets a trigger for only data 1280.

{12 TO 34 HDATA }
requires data value between 12XX and 34XX hex.  That is, 1200
through 34FF.

{F0 MASK 00 HDATA }
sets a trigger based only on the four highest bits of data. 
UniLab will look for a 0 on those lines. 

{12 TO 23 HDATA ALSO 45 HDATA}
sets a trigger on cycles where the highest byte of data is either
12 to 23, or 45 hex. 


{{COMMENTS}
You must use a special 16-bit cable with processors that use a
16-bit data bus.   That cable has two ROM plugs-- one for the
even byte, one for the odd byte.

If you need to use a large number of ALSO terms, then see NDATA.

The HDATA inputs are named for their use in the 16BIT mode.  In
the 8BIT mode they are displayed as a separate column and can be
used as for anything you like just like the MISC inputs.  On
eight- bit systems they are typically used to look at system
inputs and outputs.
~HDG` no parameters      F8

Has a fixed header for trace displays-- one that does not scroll
up with the rest of the trace.

{{USAGE}
One of the display attributes.  Usually you will toggle this with
the mode panel, function key 8.

~HDG'`no parameters       F8

Makes a non-fixed header for trace displays-- one that scrolls
with the rest of the trace.

{{USAGE}
One of the display attributes.  Usually you will toggle this with
the mode panel, function key 8.

~HELP`HELP <command>      F1

Finds the reference information for a command or feature.  With
no word, brings up the help screen, including soft-key prompt
line.

{{USAGE}
Look up information on a command, in the abridged on-line command
reference.  See also WORDS.


{{EXAMPLES

HELP}
              displays help screen.

{HELP BYE}
gives information on command "bye."
~HEXLOAD`HEXLOAD <file name>

Loads an Intel HEX format object file into the UniLab's emulation
memory.  Prompts you for the file name if you don't include it.

{{USAGE}
Load into emulation memory a program stored in Intel HEX format. 
You can then run, debug and alter that program as you would any
other.

Binary format files are more compact and load two to three times
faster.  You might want to direct your assembler to produce
binary format files, if it has that capability.  Or you can save
your program memory with BINSAVE to produce a binary format file.

Binary format files are loaded with BINLOAD.

Intel HEX format files contain the information about where each
opcode should be stored.  Be certain to have the proper sections
of emulation memory enabled before loading in the file. See
EMENABLE.

{{LOADING INTO RAM}
The UniLab will not load a file into RAM unless you have first
established debug control.  To do that you must first have a
program already loaded into emulation memory (LTARG for example)
and then run to a breakpoint with RESET <address> RB.  

If DEBUG is not in control, attempts to load memory that is not
enabled will generate an "auto-breakpoint."  You will see "-nmi-"
and then the "target address-not enb" message.  Enabled areas in
the same file will be loaded.


{{EXAMPLE

HEXLOAD MYPROG.HEX}
  load an Intel HEX format file called MYPROG.HEX.





{{COMMENTS}
Only record types 0 to 3 are supported.  Bytes 7 and 8 of each
line of the file tell what record type that line uses.

16-bit processor note:  If the UniLab detects a type 2 (extended
address) record then address bits A16-A19 will be compared to the
current =EMSEG and data will not be loaded if it is intended for
some segment other than the current one.  This will be indicated
by a
"not enb" message for each invalid address.  Enabled addresses in
the file will be properly loaded.
~HEXRCV`no parameters     

Loads an Intel HEX file from another computer, via a second
serial port.

{{USAGE}
The serial transmission must be done on a separate serial channel
with the UniLab connected to its normal serial port.  XON  and
XOFF characters are used to start and stop the data transmission.

Transmission is normally done on COM2 on IBM PC's while the
UniLab is connected to COM1. 


{{EXAMPLE

HEXRCV}
loads a hex file serially

~HLOAD`HLOAD <filename>         PPA

Loads from a file the data describing a histogram.  This is used
only with the optional Program Performance Analyzer.  You save
the information to a file with HSAVE.

{{USAGE}
Loads into memory a PPA template or a run that you previously had
saved, then automatically calls up AHIST, MHIST or THIST.

{{EXAMPLES

HLOAD AUG28.HST}
load into memory the information in the file AUG28.HST, that had
been saved with HSAVE.

~HSAVE` HSAVE <filename>        PPA

Saves to a file the data describing a histogram.  This is used
only with the optional Program Performance Analyzer, after
exiting from THIST, MHIST or AHIST.  You load the information
back into memory with HLOAD.

{{USAGE}
Save in a file a Program Performance Analyzer template or a run
that you want to keep for future purposes.   

This feature is handy when you are periodically running a
histogram of a program, and want to save the bin settings.  It
can also be used to save a particular run of the Program
Performance Analyzer.


{{EXAMPLES

HSAVE AUG28.HST}
save as a file the data that describes the last histogram screen
you saw before exiting from either AHIST or THIST.

~INFINITE`INFINITE PEVENTS       RARELY USED

Used only before PEVENTS, instead of a count, to indicate that
the trigger event must immediately follow the qualifying events.

{{USAGE}
Along with a trigger specification (see ADR, DATA, READ, WRITE,
etc.) and a qualifying event specification (see AFTER or
QUALIFIERS), when you are only interested in the trigger event if
it occurs immediately after the qualifying events.

{{BACKGROUND}
The default is for the UniLab to search for the qualifying
sequence only once.  After the sequence has been found once, it
is discarded and the UniLab looks for the trigger.  

With PEVENTS and a normal count, the UniLab searches for the
qualifying events until it finds them the count number of times. 
Then it discards the qualifiers, and looks only for the trigger.

{{WHAT IT REALLY DOES}
INFINITE causes the UniLab to search for the qualifying sequence
and then immediately look for the trigger event.  If the trigger
event is not the very next cycle, then the UniLab starts looking
for the qualifiers again.


{{EXAMPLE

123 ADR AFTER 345 ADR INFINITE PEVENTS }
triggers if address 123 follows immediately after address 345.


{{COMMENTS}
Pretty obscure.  But might be highly useful in certain restricted
situations.  

Pressing any key stops the search.
~INIT`no parameters 

Sends an initialization message to the UniLab.

{{USAGE}
To reset the UniLab after you are in the UniLab program.  

When you start up the program, it tries to initialize the
instrument after the screen has been cleared and the  UniLab
version number displayed.  If you tap any key after the screen is
cleared, then the automatic init will not occur.  You will then
have to use INIT before you can send any commands to the
instrument.

Also, if the UniLab was not properly connected when you called up
the program, or if you turned off the UniLab at any time during
the program, then the UniLab needs to be initialized.

{{IF IT FREEZES}
If the program stops after printing the
"Initializing UniLab. . . ." message, press the BREAK key while
holding down the CONTROL key.  This breaks you out of the
initializing sequence.  Make certain that you have turned on the
UniLab and connected it to the host computer.  

Try INIT again.  If it still freezes up, check the
TroubleShooting chapter.


{{EXAMPLES

INIT }
This command is never used in combination with anything else. 


{{COMMENTS}
Initializes all of the mode bits, baud rate and emulation enable
map.  Sent automatically after PROM programmer operations to
re-initialize the analyzer modes.

~INT`no parameters       RARELY USED

Generates the NMI- interrupt output when trigger state reached. 
The NMI- wire from the UniLab must be connected to either NMI or
IRQ circuit of processor.

{{USAGE-- RARE}
Useful for causing the target system to execute an interrupt
routine when it goes into trigger search state (i.e., after the
"qualifier has been found).  Used to prevent damage to equipment
by branching control to a "soft shutdown" routine when some error
condition occurs. 

You must write and install your own shutdown routine.

Orion DEBUG packages use this command internally.  If you want to
make use of it, you must disable the NMI feature of the Orion
software with the Mode Panel (F8) or with NMIVEC'.

NORMx disables the INT mode.


{{EXAMPLES

NORMT INT AFTER 123 ADR S     }
will interrupt the target processor during the bus cycle after
address 123 is reached, then trigger immediately. 

{NORMT INT 12 DATA AFTER 345 ADR S    }
will interrupt during the bus cycle after address 345 occurs,
then the analyzer will trigger when 12 data occurs.


{{COMMENTS}
The interrupt occurs when the qualifying sequence is complete,
not on trigger event.  This makes it possible to trigger on
something specific after the interrupt occurs.
~INT'`no parameters       RARELY USED

Disables the INT mode.

{{USAGE}
Rare.


{{COMMENTS}
Not often used since NORMx also disables the INT mode.
~IS`<value>  IS  <name>

Assigns a symbol name to an address or data value.

{{USAGE}
To show mnemonic names of memory locations on traces.  If you
already have an assembler generated symbol table, you will prefer
to use the symbol table features of the UniLab.  See SYMFIX and
SYMFILE.

You can use the IS command to add symbols after you have loaded
in a symbol table.  IS turns on symbol display mode.


{{EXAMPLE

1234 IS MREGISTER }
gives 1234 the symbol name "MREGISTER"  


{{COMMENTS}
Used to manually create a symbol table or to add symbols to an
existing table.  

Use SYMB to enable the symbol display on trace.  See also SYMB',
SYMSAVE, CLRSYM, SYMLOAD, and SYMFILE.   Symbol translation will
work with or without a disassembler.  
~LADR`<byte> LADR       RARELY USED
        <byte> TO <byte> LADR
   <byte> MASK <byte> LADR


Sets the truth table for the low order byte of the address
(A0-A7) separately. 

{{THE ADDRESS INPUTS}
You should normally use ADR to set 16 or 20 bits at once, but
there are limits to the use of ALSO in combination with ADR.

The UniLab gets both the address and the data from the bus during
each bus cycle. The UniLab works with up to 20-bit addresses. 
You can change the trigger specification of the least significant
byte with this command, the second byte with HADR and the high
four bytes with CONT or ASEG.  

{{USAGE}
You can use this trigger spec command in the same way you use
DATA, CONT, etc..  However, the most frequent use of this command
is to set up a trigger spec on the address lines that makes use
of many calls to ALSO. 

LADR is also useful for setting a trigger on a port address of
the Z80.   The ports of the Z80 processor have only one byte
addresses-- and the Z80 puts the contents of the A register on
the upper byte of the address lines when it outputs to a port.

{{EXAMPLE

NORMT 12 HADR  ALSO 34 LADR  ALSO 10 LADR  ALSO 5 LADR}
sets up the analyzer to trigger on any of the  addresses 1234,
1210, or 1205.


{{COMMENTS}
Makes it possible to treat the first two bytes of the address
separately.  HADR is the upper half.

~LOG`no parameters       F8
 
Enables automatic logging of target program patches on printer.  

{{USAGE}
Keeps a record of any program patches you make, but other
operations are not logged to the printer.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~LOG'`no parameters       F8

Disables logging of program patches to printer. See LOG above.

{{USAGE}
Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~LP`no parameters

Goes around a loop once and stops.

{{USAGE}
You must already have established debug control 
(see RB), and be stopped at a breakpoint within a loop. This
command allows the program to run once around the loop and stop
at the current address, displaying the registers as the UniLab
does for any breakpoint.

{{WATCH OUT}
Will not work if the program counter register is pointing above
the first instruction or below the last instruction in the loop. 
Only works when you are within the loop.  See the Target
Application Note for your processor for any additional
restrictions.

{{EXAMPLES

LP}
This command never used in combination with anything else. 

{{COMMENTS}
Works by first saving the current breakpoint address, executing N
(a single step without following branches) and then executing
<savedaddress> RB.  Processors with multiple byte breakpoint
opcodes will execute N several times.
~LTARG`no parameters 

Loads a simple target program into the UniLab's emulation memory.


{{USAGE}
A good way to gain familiarity with the UniLab.  Comes packaged
with the disassembler.  This command enables the proper section
of emulation memory and loads a simple program.  You can then use
the STARTUP command to capture a trace of your target system
executing the simple program.

{{WATCH OUT: PROCESSORS WITH EXTERNAL STACKS}
The LTARG program uses the memory map of the Orion MicroTarget. 
If your target system does not have RAM and ROM where the LTARG
program needs them, then it will not run on your board without
some patching.

The Target Application Note for each DDB includes an LTARG sample
session.


{{EXAMPLE

LTARG}
 This command never used in combination with anything else. 

~M`<byte>  M

Stores one byte in ROM or RAM and increments reference address.

{{USAGE}
Used after an ORG statement (which sets up address), to patch
program memory.  Can only be used to change RAM after debug
control has been established. See RB.

{{REMEMBERING CHANGES}
LOG sends all memory access commands such as M to the printer,
saving a record of any changes you make.


{{EXAMPLES

3000  ORG  12  M }
stores a 12 at 3000

{150  ORG   5  M  10  M}
stores 5 at location 150, 10 at 151


{{COMMENTS}
Used for entering data tables, program patches, etc.  See also
MM, MM!, and M!.  

Will store to emulated memory if the address is enabled,
otherwise will store to target RAM. See NMI and RB.

As with all memory writing commands, don't write into your stack
area when loading into RAM.

~M!`<byte> <address>  M!

Stores a byte of data at the specified address.

{{USAGE}
Used to patch program memory.  Does not require a previous ORG
command-- instead requires an address as the second parameter. 
See M.   Can also be used to change RAM, but only after debug
control has been established. See RB.

{{REMEMBERING CHANGES}
LOG sends all memory access commands, such as M!, to the printer,
saving a record of any changes you make.


{{EXAMPLES

12 3000 M!}
stores a 12 at 3000.

{5 150  M!   10 150  M!}
stores 5 at location 150, 10 at 151.


{{COMMENTS}
Used for entering small patches-- anything larger than one byte
can be done by one of the other memory patch commands with fewer
keystrokes. See also MM, MM!, and M.  

Will store to emulated memory if the address is enabled,
otherwise will attempt to store to target RAM.  See NMI and RB.


~M?`<address>  M?

Displays the byte that is stored at the specified address.

{{USAGE}
To find out what is stored at a single memory location, either
ROM or RAM.  Use MM? for looking at words, and MDUMP or DM for
larger areas of memory.

{{EXAMPLES

1210 M?}
displays the byte stored at 1210.

{{COMMENTS}
If the address is EMENABLEd then emulation memory will be
displayed, otherwise the UniLab will use DEBUG features to
display target RAM contents.  See NMI and RB.

~MACRO`no parameters

Switches the UniLab software to a macro system.

{{USAGE}
Only necessary when you want to write macros or you need access
to the "internal" words of the UniLab control program.  For
information on macros refer to the glossary entry on : (colon),
and Appendix F of this manual.  For information on internal
commands and other subjects, order the UniLab Programmer's Guide
from Orion.

Several otherwise unused files must be in the UniLab directory
when you request that the software switch to macro system. 
Included on your distribution diskette are the files necessary
both for the operator system, with a .OPR extension, and for the
macro system, with a .MCR extension.   You should have one .OPR
and one .MCR file for every .EXE or .OVL file.  

When you switch to macro system, the UniLab software will search
for a .MCR file whose name matches the current .EXE file.   

If you had previously saved the system to a different name (using
SAVE-SYS), you will have to rename the .MCR so that it matches
your executable file before you can make a macro system. 

You can save the UniLab software as a macro system anytime after
you use the command MACRO.  SAVE-SYS will save, to the new name
you specify, a .EXE file and a matching .MCR file.

In the operator system (see OPERATOR and MAKE-OPERATOR) you have
access only to the commands in the UniLab glossary.


{{EXAMPLE

MACRO }
Converts to macro system. 
~MAKE-OPERATOR`   MAKE-OPERATOR <file1> <file2>       Macro Sys

Use this command to create an operator system that has restricted
access to the UniLab program, but also has access to the words
that you have defined. 

{{USAGE}
This command performs four actions:
     1) save the macro system to the first name,
     2) create a non-standard operator system, 
     3) save the new system to the second name, and
     4) exit to DOS.

The new, non-standard operator system recognizes the new commands
that you have defined in your macro system.

The standard operator system gives you access only to the
commands in the UniLab On-Line Glossary.   

{{FILE NAMES}
When you create an operator system with this command your UniLab
directory must contain the MAKE file from your distribution
diskette.  


{{EXAMPLE

OPERATOR MACROZ80 TESTER}
Saves a macro system with the name MACROZ80, then creates an
operator system and saves that software to the name TESTER.EXE,
with associated file TESTER.OPR.
~MAPSYM`MAPSYM <filename>

Reads from a .MAP file the information the UniLab needs to
provide high level language support.  Clears out the symbol table
before loading the information.  See also MAPSYM+.

{{USAGE}
Reads in from a .MAP file the information needed for display of
high-level language source files in the trace.  After you issue
this command, each line of your source code file will be
displayed just before the instructions that the line generated.

You can use SYMLIST to see the contents of the symbol table after
you load a .MAP file.   You can save the entire symbol table with
SYMSAVE, and reload it later with SYMLOAD.

You must have your source files in the current directory, or they
will not be found.

{{.MAP FILE FORMATS}
You can use either a MicroSoft format .MAP file or an ORION
format file, described below.  The MicroSoft .MAP file contains a
mixture of symbol and line number data.

The Orion format is much simpler, which makes it easier to
generate a .MAP file.  It contains only line number information.

{{ORION .MAP FORMAT}
The Orion format .MAP file is an ASCII file which contains a
series of file records, one for each source file.  You can have
any number of file records per .MAP file.

The first line of each record starts with the keyword SOURCE,
followed by a space and then the name of the source file.  The
remainder of each file record contains two numbers per line: the
line number, then the absolute 16 bit address of the code
generated by that source line.

A file record is terminated by a blank line.  The .MAP file is
terminated by two blank lines.  Every line of the .MAP file must
end in a carriage return and a line feed (ASCII codes 0DH and
0AH).


{{ORION .MAP FILE--EXAMPLE}
The following is a simple example of a valid Orion format .MAP
file.  This file describes the relationship between source files
and machine code for a simple C program.  The program was
generated from two source files.  Notice that only some lines of
the source file generated code:

{SOURCE SIMPLE1.C}
{2 0034}
{5 0040}
{6 0050}
                                                  <blank line>
{SOURCE SIMPLE2.C}
{3 0055}
{5 0070}
                                                  <blank line>
                                                  <blank line>

{{DISABLE}
You turn off the display of high level source files with SOURCE'.


{{EXAMPLE

MAPSYM TEST.MAP}
loads into the symbol table the information in .MAP file
TEST.MAP.  The source files themselves are not opened until they
are needed, while looking at a trace display or at a disassembly
from memory.





~MAPSYM+`MAPSYM+ <filename>

Same as MAPSYM, except that it does not clear the symbol table
before loading the .MAP file.

~MASK`<byte> MASK <byte> 

Specifies a mask for the trigger spec that immediately follows.

{{USAGE}
A modifier to ADR, CONT, DATA, HADR, HDATA, LADR,  or MISC.  

The first byte describes which of eight wires to pay attention
to-- a one means pay attention, a zero means don't care.

The second byte tells the UniLab what inputs to look for on the
wires that you care about.  The UniLab ignores the bits for the
inputs that the first byte told it to ignore.  Thus 01 MASK 01
has the same affect as 01 MASK FF.


{{EXAMPLES

NORMT 2 MASK 2 MISC S }
will trigger if input M1 goes high. 

{NORMT B# 0010 MASK B# 0010 MISC S }
has the same effect as the first example-- will trigger if input
M1 goes high. 

{NORMT 3 MASK 2 MISC S }
requires inputs M1=1, MO=O for trigger.


{{COMMENTS}
MASK cannot be used with TO, NOT, ALSO

~MCOMP`<start addr> <end addr> <comp addr> MCOMP
     
Compares two areas of memory and indicates discrepancies. 

{{USAGE}
Compares the two areas of memory, and gives you a message about
each discrepancy.  Press any key to abort. For example:

110 117 810 MCOMP
Data is 16 at addr 0110 ..but is  5 at addr 0810
Data is 90 at addr 0112 ..but is 80 at addr 0812
Data is 27 at addr 0116 ..but is 23 at addr 0816

You only need to enter three addresses-- the starting and ending
address of the first block of memory, and the starting address of
the second.

{{VERIFYING ROMS}
If you want to compare a ROM to a program on disk, first load the
program using BINLOAD or HEXLOAD.  After that use the PROM READER
MENU to read from the PROM into a different memory area.

You can then use MCOMP to compare the two target areas.


{{EXAMPLE

100 300 800 MCOMP }
compares data at target addresses 100-300 to the data at 800-A00.


{{COMMENTS}
Works on either emulated ROM or target RAM.  See NMI and RB.
~MDUMP`<from addr> <to addr>  MDUMP

Display the contents of an area of memory. 

{{USAGE}
Allows you to look at any block of memory. For example:
 
121 131 MDUMP  
 
121   F3 31 00 1C 21 78 02 11  78 02 01 2C 00 7C BA C2  
.1..!x..x..,. .. 
131   38 01 7D BB CA 42 01 7E  12 23 13 0B 79 B0 C2 38   8.}..B.
.#..y..8 
 
Press any key to freeze scrolling of display.  Press any key
again to continue scrolling.  While scrolling is stopped, press
any key twice quickly to stop.


{{EXAMPLE

1234 1334 MDUMP }
displays the contents of locations   1234 to 1334 in hex and
ASCII.


{{COMMENTS}
As with all M commands, display will be from emulation memory if
the address has been EMENABLEd, otherwise DEBUG features will
display target RAM memory.  See NMI and RB.
~MEMO`no parameters       SHIFT-F2

Displays and allows editing of the on-line memo pad.

{{USAGE}
A handy way to write notes to yourself.  Pressing CONTROL and Z
at the same time toggles the on-line editor help screen on and
off.  This screen shows you the ESCape key sequences and ConTRoL
key combinations that you use with the editor.   See COMMENTS
below.

You exit the full screen editor with ESCAPE followed by F if you
want to save the changed memo pad.  ESCAPE followed by ESCAPE
allows you to leave the memo pad without saving your changes.


{{EXAMPLE

MEMO }
This command never used in combination with anything else.       
        


{{COMMENTS}
This command works only when the EDITxx.VIR file is present in
the same directory as the UniLab program.

The powerful editor allows you to write complicated macros and
enable them at will.  If you want to use this feature to the
fullest, order the PADS manual from
                       Mountain View Press
                           PO Box 4656
                     Mountain View, CA 94040






EDITOR HELP (repeated on-line):

Press SHIFT-F2 to get the editor.
Once in the editor, press CTRL-Z to get the on-line help.

Press WHILE HOLDING DOWN THE CONTROL KEY:

CURSOR CONTROL:
S=LeftD=Right
E=UpX=DownQ=Home
F=RtabI=Ltab
F=ForwdA=Bkwrd      

CHARACTER CONTROL:  LINE CONTROL:       
 Del=Delete char     K=Kill line        
 J=Jerk-->buffer     G=Gobble-->buffer  
 C=Chars<--buffer    Y=Copy-->buffer    
 V=Insert chars      L=Line<--buffer    
 P=Pullup words      N=New lines        



Press THE ESCAPE KEY AND FOLLOW WITH:

 ESC=Esc no update   F=Updat & Fin edit
 W=Word for search   B=Updat & Back scr
 S=Search screens    N=Update & Nxt scr
 U=Update now        L=Update & Load
 R=Restore screen

~MENU`no parameters       F10

Selects the menu-driven mode.

{{USAGE}
The menu- driven mode helps first time users by allowing you to
use the UniLab simply by choosing from list of options.  This
command, whether typed in or picked with function key 10,
reassigns the function keys and shows the menu on the screen.  
The command line that you would use gets displayed as it is
executed, so you can learn how to enter the command directly.  

While using the menu, you can also type commands directly.

Menu mode also comes in handy when you have forgotten a command.

All PROM programming commands are available under the PROM menu.

Pressing F10 again from the main menu gets you out of menu mode.


{{EXAMPLE

MENU}
This command never used in combination with anything else. 
~MESSAGE`no parameters

Gives a screenful of information on the most recent updates and
additions to the UniLab software.

{{USAGE}
Make certain that you know all the capabilities of the UniLab
software.  

~MFILL`<from addr> <to addr> <byte>  MFILL

Fills every location in an area of memory with the same byte.

{{USAGE}
A good way to check that memory address and data lines connect
properly on the target board.  You can fill an area of memory,
and then examine it with MDUMP.  

One way to find out what is happening on your board when LTARG
test program will not run:  fill a block of memory with NOOP
instructions, starting at the reset address, and then use
STARTUP.   You should see a trace of consecutive addresses.
  
Also a heavy-handed way to push a byte into memory.  See also MM,
M, MM!, and M!, for more elegant ways to manipulate memory.



{{EXAMPLE

1200 1300 20 MFILL }
fills locations 1200-1300 with the value 20 hex.


{{COMMENTS}
As with all memory writing commands, don't write into your stack
area when loading into RAM.

~MHIST`no parameters            PPA

Multiple-Pass HISTogram invokes the optional Program Performance
Analyzer (PPA), which allows you to display the execution time of
your target program in each of up to 15 user-specified address
ranges. See also THIST and AHIST.

{{USAGE}
Allows you to examine the performance of your software.  You can
find out where your program is spending most of its time.

Press F10 to exit from this menu-driven feature.

You must (only once) issue the command SOFT to enable this
optional feature.  SOFT performs a SAVE-SYS, and then causes an
exit to DOS.  The next time you call up the software, the PPA
will be enabled.

{{MENU DRIVEN}
You produce a histogram by first specifying the upper and lower
limits of each address "bin" that you want displayed, then
starting the gathering of data.

When you give the command MHIST you get the chart screen with the
cursor positioned at the first bin.  You can then start typing in
the lower and upper limits of each bin.  Use return, tab or an
arrow key after you enter each number, to move to the next entry
field.

Press function key 1 (F1) or ALT-F1 to start displaying the
histogram.

{{SAVE TO A FILE}
You can save the setup of a histogram as a file with the HSAVE
<file>.  Issue this command after you exit from the histogram.

You load the histogram back in with HLOAD <file>.  This command
also invokes the histogram.

{{EXAMPLE

MHIST}
This command is never used in combination with anything else.
~MISC`<byte> MISC
<byte> TO <byte> MISC
  <byte>  MASK <byte> MISC
Changes the analyzer trigger for the miscellaneous inputs.

{{THE MISCELLANEOUS INPUTS}
The UniLab's 48-bit-wide trace buffer has room for 8 more bits
than are used for data, address, and control lines.  These eight
input lines are available to you, for sensing anything on the
target board that you want to know about, or that you want the
UniLab to trigger on.

For example, you might hook them up to an output port, to trigger
when a particular bit configuration gets asserted on that port.

The qualifier and filter specifications always ignore the MISC
inputs.

{{USAGE}
The simplest use sets up a trigger for a single value on
miscellaneous inputs.  The UniLab will search for the byte value,
and trigger when it sees that hex number on the lines.  See the
first example below.

{{RANGES}
TO lets you set up a trigger on any input between two byte
values, inclusive.   See the second example below. 
{{NOT}
NOT causes the UniLab to trigger when the value falls outside the
specified range or value.    

{{MASKING}
You can use k MASK l MISC to examine any subset of the 8
miscellaneous lines.  This is particularly handy when you only
have one or two of the MISC inputs connected to your board.  You
don't care about the logic level of the other 6 lines, since they
don't mean anything. 

The high bits of k mark which bits will be examined, while the
bit configuration of byte l indicates the values the lines must
have for a trigger to occur.



(continued on next page)                      
(continued from previous page)

For example, 03 MASK FF MISC selects only  bits M0 and M1 for
examination (with binary value 0000 0011). The UniLab would
trigger when both these bits have a high value.  The instruction
03 MASK 03 MISC would have the same effect.

{{WITH TRACING}
All trace filtering modes and qualifiers ignore the MISC inputs.
Since they still effect triggering, this makes the MISC inputs
particularly useful as trigger inputs for filtered traces.


{{EXAMPLES

NORMT 12 MISC S }
after clearing all previous settings with NORMT, sets up a
trigger for miscellaneous input 12, then uses S to start the
analyzer.

{12 TO 34 MISC }
requires miscellaneous input value between 12 and 34 hex.  

{F0 MASK 00 MISC }
sets a trigger based only on the four highest bits. The UniLab
will look for a 0 on those lines. 
{23 MISC ALSO 45 MISC}
sets a trigger on cycles where the misc input is either 23 or 45
hex. 

{{COMMENTS}
The MISC inputs can be connected to anything you like.  They are
often used to look at system input and output ports.

~MISC'`MISC' FILTER       RARELY USED

Used only before FILTER to enable trace filtering on all inputs
except the MISCellaneous wires(M0 to M7). NORMx turns this mode
off.

{{WHY YOU DON'T NEED TO BOTHER}
Because this is taken care of for you by ONLY and by xAFTER, so
it is unlikely that you will need to use this command.

See also CONTROL, HDAT, and NO.


{{EXAMPLE

MISC' FILTER }
enables filtering on all except M0-M7 inputs.
~MLOADN`<start> <end> <targ addr> MLOADN       RARELY USED

Moves a block of memory from the memory of the host to the target
memory.

{{USAGE}
Allows you to assemble or load a program into host memory, and
then move it to UniLab emulation ROM or target RAM.  

Most people will prefer to assemble into a file, and then load
from the file into UniLab emulation memory.

{{FREE MEMORY}
The host memory area that is available generally starts right
above C000.  PAD 100 + U. displays the first free address.  SO U.
shows you the upper limit of the unused memory.


{{EXAMPLE

C000 C800 0 MLOADN }
moves data at C000-C800 in the host computer to target locations
0-800.
                         

{{COMMENTS}
You must have emulation memory enabled to load the program into
ROM (see EMENABLE).  

~MM`<word> MM

Stores one 16-bit word in ROM or RAM and increments reference
address.

{{USAGE}
Used after an ORG statement (which sets up address), to patch
program memory.  Can only be used to change RAM after debug
control has been established. See RB.

{{REMEMBERING CHANGES}
LOG sends all memory access commands such as MM to the printer,
saving a record of any changes you make.


{{EXAMPLES

3000  ORG  1210 MM}
 stores 1210 at 3000. 

{150  ORG   5000  MM  7001 MM}
stores 5000 at location 150,    7001 at 152.


{{COMMENTS}
Used for entering data tables, program patches, etc.  See also M,
MM!, and M!.  

Will store to emulated memory if the address is enabled,
otherwise will store to target RAM.   See NMI and RB.

As with all memory writing commands, don't write into your stack
area when loading into RAM.

If you have a disassembler the byte order is set correctly,
otherwise you can set it with HL or LH. 

~MM!`<word> <address>  MM!

Stores a 16-bit word of data at the specified address.

{{USAGE}
Used to patch program memory.  Does not require a previous ORG
command-- instead requires an address as the second parameter. 
See MM.   Can also be used to change RAM, but only after debug
control has been established. See RB.

{{REMEMBERING CHANGES}
LOG sends all memory access commands, such as MM!, to the
printer, saving a record of any changes you make.


{{EXAMPLES

1200 3000 MM!}
stores a 1200 at 3000

{5000 150  MM!   1000 152  MM!}
stores 5000 at location 151, 1000 at 153.


{{COMMENTS}
Used for entering small patches-- anything larger than one word
can be done by one of the other memory patch commands with fewer
keystrokes. See MM and M.  

Will store to emulated memory if the address is enabled,
otherwise will attempt to store to target RAM.  
As with all memory writing commands, don't write into your stack
area when loading into RAM.

If you have a disassembler the byte order is set correctly,
otherwise you can set it with HL or LH.  
~MM?`<address>  MM?

Displays the 16-bit word that is stored at the specified address.

{{USAGE}
To find out what is stored at a single memory location, either
ROM or RAM.  Use M? to look at bytes and MDUMP or DM for larger
areas of memory.


{{EXAMPLE

1210 MM?}
displays the word stored at 1210.


{{COMMENTS}
If the address is EMENABLEd, then emulation memory will be
displayed.  Otherwise the UniLab will use DEBUG features to
display target RAM contents.  See NMI and RB.

If you have a disassembler, the byte order is set correctly,
otherwise you can set it with HL or LH.  

~MMOVE`<start addr> <end addr> <dest>  MMOVE

Moves a block of memory from one area to another in the target
memory space.

{{USAGE}
Good way to make a little more room when you need to patch some
extra code into a program.

You can also use it to relocate a relocatable code module.

{{SMART MOVER}
Automatically chooses the order of moving, to prevent overwriting
caused by moving from one area to an area that overlaps.  Starts
moving from either the beginning or the end of the area to be
moved, as necessary.  See the two examples below.


{{EXAMPLES

1000 2000 1005 MMOVE }
moves the data in locations 1000-2000 up 5 places.  Starts moving
from the end.

{200 300 125 MMOVE}
moves the data in 200-300 down 75 spaces.  Starts moving from the
beginning.


{{COMMENTS}
Make certain that the code you moved is relocatable.  If it is
not, you might have to patch some of the absolute address
references.  In general, exercise caution, and use DM on the
moved memory, to see if the instructions still do what you want
them to do.

As with all memory writing commands, don't write into your stack
area when loading into RAM.

~MODE`no parameters       F8

Gives you the mode panels, which allow you to change mode of
display, disable and enable the DEBUG, etc.

{{USAGE}
Press function key 8 (F8) once to get the first mode panel, which
contains the analyzer mode switches. Press F8 again to get the
second panel that contains the trace display mode switches.  The
third panel contains the log mode switches and debug disable
switches.


{{MOVING AROUND}
To get from one panel to another, press F8 repeatedly, or use
PgDn key.  Use the END key to exit from mode setting.

Once you are in a pop-up panel, you can move around, selecting
different features, with the up arrow and down arrow keys.  The
right arrow key toggles the feature on and off.

{{WHAT THEY ALL DO}
See the Special Functions section of the manual for the complete
story.  

You can also check the listings in the glossary for each feature:
{{Panel One      DASM      SYMB      RESET   
{{Panel Two      SHOWM     SHOWC     =MBASE   PAGINATE  HDG
{{Panel Three    LOG       TOFILE    PRINT    NMIVEC    RSP


{{EXAMPLE

MODE}
This command never used in combination with anything else. 
~MODIFY`<addr> MODIFY

Dumps a screenful of memory, in a format similar to MDUMP, but
also puts the cursor on the first location and lets you alter any
location by overwriting the old value with a new one.

{{USAGE}
The best way to display and alter memory.  The interactive screen
display shows you the value in each location and lets you alter
any value.  

You can alter any location by typing in a new hexadecimal value
or by moving to the ASCII area and typing a character.

Press the End key to exit from MODIFY.

{{MOVING AROUND}
The cursor keys move the cursor around on the screen.  If you try
to move up or down off the screen with an arrow key, one new line
of memory will be bought onto the screen.

PgUp moves up one screenful, PgDn moves down one.

Use Ctrl-Right Arrow to move from the hexadecimal dump area to
the ASCII.  Ctrl-Left Arrow moves the cursor back.


{{EXAMPLE

20 MODIFY}
Displays a screenful of memory, starting at address 20.  The
cursor keys will be reassigned as described above (and on the
prompt line) until you press either End to save changes and exit,
or Esc to exit without saving changes.
~MS`<count> MS       RARELY USED

Pauses for count number of milliseconds.

{{USAGE}
In test programs where you need a pause.

400 (hexadecimal) milliseconds is one second.


{{EXAMPLE

800 MS }
pauses for 2 seconds (800 hex ms)

~N`no parameters

Resumes program, with a breakpoint set to the address after the
next instruction.

{{USAGE}
While stopped at a breakpoint, when you want to execute only the
next instruction pointed to by the Program Counter.  However, you
will "fall through" loops and branches.

This "falling through" is often very useful.  For example, if the
PC is pointing at a subroutine call, N will show you the state of
the processor when it returns from the call.

Use NMI to follow the execution of loops and branches.

{{FALL THROUGH LOOPS}
When you single-step through a program, you will usually not want
to bother going through loops the same number of times that the
microprocessor does.  This command allows you to go through a
loop just once.

{{HOW IT WORKS}
This command uses RB to set a breakpoint at the address just
after the disassembled instruction that the PC points to.  So the
program runs until it reaches that address.  

{{WATCH OUT}
If the program never reaches the address of the  breakpoint, then
the program will run without stopping.  For example, if the
program contains an infinite loop, and you will not want to use N
on the last command in the loop (the jump back up to the top). 
The program never reaches the code that follows that last jump.


{{COMMENTS}
Available only after DEBUG control has been established.
~NDATA`<byte #1> <byte #2>  . . .  <byte #N> <N>  NDATA

Sets N different bytes as trigger events for the analyzer.

{{USAGE}
A quick way to set triggers on many different data codes that do
not fall into ranges.  Easier than using ALSO again and again, as
in:
18 DATA ALSO 32 DATA ALSO 36 DATA ALSO 47 DATA.

{{RANGES OF DATA}
If the data does fall into ranges, then you can use TO instead. 
For example, 12 TO 25 DATA sets the analyzer looking for any data
between twelve and 25, inclusive.

{{EXAMPLE

18 32 36 47  4  NDATA }
Does the same thing as the ALSO example in the text above.


{{COMMENTS}
Really the same as "ORing" together the terms with ALSO.  Any
number of terms can be listed, but be sure to get the count
correct. 

You can use ALSO in combination with this command to add a range
of values.

~NMI`no parameters       F4

Either establishes DEBUG control immediately or, if you already
have DEBUG control, executes a single instruction.

{{USAGE}
Now supported on all DEBUG software packages.   Uses either the
non-maskable interrupt pin (NMI) or the interrupt request pin
(IRQ) of the target processor.

Allows you to establish debug control on a program that is
currently running.  See also RB and RI.  

{{AUTO-BREAKPOINT}
You can now read or write RAM and I/O without first gaining DEBUG
control-- the UniLab will automatically do it for you.  When you
try to read RAM while a program is running, the UniLab will issue
an NMI signal, gain DEBUG control, perform the requested function
and then allow the program to resume.

{{SINGLE-STEPPING}
After you have established DEBUG control, the NMI command allows
you to execute one instruction, no matter what that instruction
is.  See also N.  

NMI is especially useful for following jumps and branches--
instructions that N cannot follow.

{{DISABLE}
If your target board makes use of the non-maskable interrupt (or
IRQ) feature of your processor, or you wish to disable NMI for
any other reason, use the Mode Panel (F8) or NMIVEC'. 

Disabling the DEBUG features (Mode panel choice "SWI VECTOR" or
command RSP') also disables NMI.

{{COMMENTS}
The hardware interrupt feature is also utilized by SI.  Disabling
NMI also disables that feature.
~NMIVEC`no parameters       F8

Enables the Non-Maskable Interrupt vector installation.
 
{{USAGE}
This command re-enables the UniLab's ability to perform NMI.  You
only want to disable this feature when you want more transparent
operation and don't need to use all DEBUG features.  See RSP' for
complete transparency.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~NMIVEC'`no parameters       F8

Disables the Non-Maskable Interrupt vector installation.
 
{{USAGE}
This command disables the UniLab's ability to perform NMI.  

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

The DEBUG features include the ability to send either a non-
maskable interrupt (NMI) or an interrupt request (IRQ) to the
microprocessor.  Orion software packages use this feature to gain
DEBUG control over your processor at any time.  

{{WHEN YOU WILL WANT TO DISABLE NMI}
When your system makes use of the NMI or IRQ, and you want to
preserve that ability while testing the system.


{{COMMENTS}
Either the panel toggle or NMIVEC re-enables the vector
installation.
~NO`NO FILTER       RARELY USED

Used before FILTER to disable the filter.

{{USAGE -- RARELY USED}
You will probably never use this command.  Used only when you
want to turn the filter off while preserving the current trigger
spec.

The filter mechanism of the UniLab gets turned on for you by the
xAFTER macros.  Those commands set the filter to MISC' FILTER,
which allows  you to set up a trigger spec based on all inputs
except for the MISCellaneous wires.

See also CONTROL, HDAT and MISC'.


{{EXAMPLE

NO FILTER }
turns off the filtering of bus cycles, but leaves the rest of the
trigger spec untouched.

~NORMB`no parameters

Clears out (NORMalizes) all trigger descriptions and sets the
trigger event near Bottom of trace buffer.

{{USAGE}
To start a new trigger definition when you want to see the events
that led up to the trigger.

Use TSTAT to look at how this command changes the DCYCLES
setting.

When you want to start from scratch with a new trigger
description, always begin with one of the variations of NORM. 
The three commands, NORMB, NORMM, and NORMT, vary only in where
within the trace buffer they place the trigger event-- at the
bottom, in the middle or at the top.

{{TO SEE WHAT HAPPENS NEXT}
S+ restarts the target board with the same trigger specification,
but with 170 (decimal) added to the delay cycle count, so that
you can see what happened after the current trace window.

{{HOW THEY WORK}
The commands clear out the truth tables the analyzer used to
search for the trigger event, and set the number of delay cycles
that the analyzer will wait between seeing the trigger and
freezing the buffer.  See DCYCLES for more information about
delay cycles.


{{EXAMPLES

NORMB}
 Sets 4 delay cycles

{NORMB NOT 0 TO 1000 ADR S     }
will show what happened before the address went outside of the
0-1000 range.


{{COMMENTS}
NORMB should be used where you want to know what happened before
the trigger.  
~NORMM`no parameters

Clears out (NORMalizes) all trigger descriptions and sets the
trigger event at Middle of trace buffer.

{{USAGE}
To start a new trigger definition when you want to see the events
that led up to the trigger, and also see what followed.  

You will find it very useful when you want to see the complete
context within which the trigger occurred.

Use TSTAT to look at how this command changes the DCYCLES
setting.

See NORMB for more details.


{{EXAMPLE

NORMM}
sets delay cycles to 85 (decimal).

~NORMT`no parameters

Clears out (NORMalizes) all trigger descriptions and sets the
trigger event near Top of trace buffer.

{{USAGE}
To start a new trigger definition when you want to see the events
that followed the trigger.

Use TSTAT to look at how this command changes the DCYCLES
setting.

See NORMB for more details.


{{EXAMPLE

NORMT}
sets delay cycles to 165 (decimal).
~NOT`NOT  <trigger description>

The trigger description gets interpreted as a description of when
not to trigger.

{{USAGE}
To tell the analyzer to trigger when some byte of the 48-channel
input bus goes outside of a certain range or value.  Most
commonly used to trap bad data or a bad address.


{{EXAMPLES

NORMT   NOT 00 TO 4FF ADR S }
triggers if the address goes outside the 00 to 4FF range. 

{ONLY 127 ADR NOT 12 DATA S }
shows only cycles where the data at 127 address is not 12. 

{NORMM   NOT 12 DATA  ALSO   NOT 34 TO 56 DATA  S}
triggers when the data is not either 12 nor between 34 and 56.


{{COMMENTS}
Sets a flag for the next trigger word (ADR, CONT, DATA, HADR,
HDATA, LADR, and MISC). 

Except when used with ALSO, the NOT command causes the truth
table to be cleared to all 1's.  Then 0's get written into the
specified areas.  This is the opposite of what happens without
NOT.

With ALSO, the NOT command does not clear out the truth table
first.

~NOW?`no parameters

Shows you what is happening on the target board right now.

{{USAGE}
To see the code the microprocessor executes during the next 170
bus cycles. 


{{EXAMPLES

NOW?}
 This command never used in combination with anything else. 



{{COMMENTS}
This command is a simple macro that turns off the RESET, so that
it does not restart the target board, then sets its own trigger
and captures a trace.
                   
~ONLY`ONLY  < trigger description >

Gives you a trace buffer filled only with cycles that match your
description.

{{USAGE}
Clears out the previous trigger spec and enables trace filtering.

Only the bus cycles that contain the trigger cycle will be
recorded. 

Use this command when you want to see on the trace only the cycle
described in the trigger specification. For example, only the
read cycles, or only the command at address 0100.

{{ELIMINATE BORING LOOPS}
This command is especially useful for filtering out status and
timing loops that hog the trace space.  See the second example
below.

Notice that when filtering you have to use AFTER if you want to
start the trace at some particular point in the program.

{{ONLY AND THE DISASSEMBLER}
You will sometimes want to turn off the disassembler while using
this feature.  Disassembling partial instructions will give
confusing results. Either the mode panel (F8) or DASM' turns off
the disassembler.


{{EXAMPLES

ONLY READ }
searches for and records only the read cycles.

{ONLY  NOT  120 TO 135 ADR  AFTER 750 ADR  S}
produces a trace starting at address 750, excludes from the trace
the routine at addresses 120 through 135.

{ONLY 0100 ADR}
records only the cycle executed at address 0100.





{{COMMENTS}
The analyzer will run until the trace buffer is full while
keeping you informed of the number of spaces remaining.  You can
stop the analyzer at anytime by pressing a key.  Then enter TD to
see what you have captured in the trace buffer.  

~OPERATOR`no parameters       Macro Sys

Switches the UniLab software back to operator level.

{{USAGE}
Your UniLab software was an operator system when you received it.

You use this command after you have created a macro system with
the command MACRO and now wish to return to the operator system.

The operator system you create with this command will not
recognize any words you defined while in the macro system.  See
MAKE-OPERATOR to find out how to make an operator system that
recognizes your macros.

The operator system gives you access only to the commands in the
UniLab On-Line Glossary.   The operator system has less power
than the macro system, but contains enough power for all of your
usual work with the UniLab. 

{{FILE NAMES}
If you request that the software switch back to operator system,
your UniLab directory must contain a .OPR file which matches the
name of your current .EXE file.  

When you save a macro system you specify a new name that gets
used for both the .EXE and the .MCR files.  If that name was
different from the original file name, you will now have to
rename your original .OPR file before you can return to an
operator system.  

Use the DOS command COPY to make a copy of your .OPR file which
has the same name as your current .EXE file.  
Of course, if you had saved the macro system to a new name, then
you could call the old standard operator software from DOS,
rather than switching to a new standard operator system.  See
MAKE-OPERATOR to create a non-standard operator system.

{{EXAMPLE

OPERATOR }
Converts software back to operator system. 
~ORG`<address>  ORG

Sets the origin (address at which you will start to poke new
values into memory) for subsequent M and MM commands.

{{USAGE}
To change the information stored in several sequential bytes of
program or data memory.  

You can alter emulation ROM at any time.  If you keep NMI
enabled, you can alter RAM at any time, since the Orion software
will automatically gain DEBUG control, read the RAM and then
resume execution of the target program.

If you disable NMI (see NMIVEC'), then you will need to run to a
breakpoint before reading from RAM.  See RB.


{{EXAMPLES

101 ORG 12 M 3410 MM }
stores 12 to location 101 and 3410 to locations 102 & 103.


{{COMMENTS}
Useful for entering program patches.

See also M! and MM!.

~PAGE0`no parameters

Only for UniLabs with 128K of memory.  Selects the bottom 64K
page of emulation memory.

{{USAGE}
Addresses that are four hex digits long (16 bit binary numbers)
cover a 64K memory space, but your UniLab has 128K memory space. 
You must establish a context for the addresses to follow.  

This command sets the offset to 0000, while PAGE1 sets the offset
to 10000.  Thus, address 1300 after PAGE0 refers to location
1300.  Address 1300 after PAGE1 means location 11300.


{{EXAMPLE

PAGE0 }
 This command never used in combination with anything else. 

~PAGE1`no parameters

Only for UniLabs with 128K of memory.  Selects the top 64K page
of emulation memory.

{{USAGE}
See PAGE0  above.

Address 1300 after PAGE1 means location 11300.


 {{EXAMPLE

PAGE1}
  This command never used in combination with anything else. 

~PAGINATE`no parameters       F8

Enables pagination of trace display.

{{USAGE}
The default condition.  The trace stops after each screenful.  

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

You can turn this off with the pop-up panel, or with PAGINATE'.

{{COMMENTS}
If you press any key while display is scrolling, trace display
will stop.

~PAGINATE'`no parameters       F8

Disables pagination of trace display. 

{{USAGE}
The trace display will scroll by continuously.  Not very useful,
unless you want to save an entire trace to a disk file.  See
PAGINATE above.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~PATCH`no parameters

Redisplays the menu of processors supported by the current DDB
software. 

{{USAGE}
Use when you make an error choosing your processor from the menu,
or if you want to try a different configuration.


{{EXAMPLES

PATCH }
This command never used in combination with anything else.


~PCYCLES`<count>  PCYCLES

Sets the number of bus cycles that the analyzer waits between
seeing the last qualifier and starting to search for the trigger
event.

{{USAGE}
The default is zero.  Usually you will want the analyzer to start
its search for the trigger event immediately after the
qualifiers.

However, you will sometimes want the UniLab to wait some number
of cycles after the qualifiers, before it looks for the trigger. 


For example, you know that the program jumps to address 1000 from
address 235.  What you can't understand is why the code at
address 1000 is being executed again, later on.  So you do not
want the UniLab to search for address 1000 until some time has
passed since it saw address 235.


{{EXAMPLES

NORMB 1000 ADR 10 PCYCLES AFTER 235 ADR S  }
triggers if 1000 occurs 10 or more cycles after address 235.


{{COMMENTS}
A pass cycle count can be used to hold off the search for a
trigger, for whatever reason.

If there are several qualifiers the pass count starts after the
complete sequential qualifier sequence has occurred.
~PEVENTS`<n>  PEVENTS

Sets the number of times the UniLab will want to see the
qualifying events before starting to search for the trigger
event.

{{USAGE}
The default value is one-- the UniLab will start to search for
the trigger as soon as it has seen the qualifying event once.

You would use PEVENTS when you don't want to search for the
trigger until the qualifiers have been seen a number of times. 
Useful for catching a trace after the nth iteration of a
sequence.

This command is different from PCYCLES, which delays searching
for the trigger an absolute number of bus cycles after the
qualifiers have been seen. 


{{EXAMPLES

NORMT   12 DATA 4 PEVENTS AFTER 30 DATA   S  }
searches for 12  data anytime after 30 data has been seen four
times

{NORMT   100 PEVENTS AFTER 123 ADR   S  }
triggers as soon as address 123 has occurred 100 times.
~PINOUT`no parameters

Displays pinout of target processor.

{{USAGE}
A handy reference showing signal names and analyzer cable
connections versus pin numbers.


{{EXAMPLE

PINOUT }
This command never used in combination with anything else. 

~PPA`no parameters

Call up the Program Performance Analyzer Menu.

{{USAGE}
Gets the menu from which you can select the PPA features.
     

{{EXAMPLE

PPA }
This command never used in combination with anything else. 
          
~PRINT`no parameters       F8

Logs all screen output to the printer.

{{USAGE}
Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~PRINT'`no parameters       F8

Turns off logging all screen output to printer.

{{USAGE}
Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~PROMMSG`no parameters

Use after a STANDALONE EPROM programming command, to display
completion message.

{{USAGE}
You use STANDALONE when you want to make use of your host
computer while the UniLab is programming an EPROM.  After the
programming light goes out, you can use PROMMSG to check the
outcome of the programming operation.

~Q1`Q1 <trigger spec>       RARELY USED

Selects the event description (trigger spec) that follows as
qualifier one.  
See QUALIFIERS.

{{USAGE}
When you don't want to use AFTER, which you will find to be a
more natural way to set qualifiers.

You will rarely use this, since AFTER automatically increments
the context from TRIG to Q1 to Q2 to Q3 each time it is used. 
You will find these words handy when you want to change your mind
about one of the qualifying steps without entering the entire
definition again.


{{EXAMPLES

Q1 15 LADR}
Changes qualifier number one, so that the UniLab looks for 15 on
the low byte of the address lines.

{Q1 ALSO 28 LADR}
Alters qualifier one, so that the UniLab accepts either 15 or 28
on the low byte of the address.

~Q2`Q2  <trigger spec>       RARELY USED

Selects the event description that follows as qualifier number
two.  See Q1 for details.

~Q3`Q3  <trigger spec>       RARELY USED

Selects the event description that follows as qualifier number
two.  See Q1 for details.

~QUALIFIERS`<1, 2, or 3> QUALIFIERS       RARELY USED

Selects the number of qualifying events.

{{USAGE}
Allows you to reduce the number of qualifying events.  Usually
you'll use AFTER to set qualifiers, and would use this command
only to reduce the number of qualifiers if you change your mind.

When there are qualifiers, the UniLab searches for the qualifying
events before it looks for the trigger.

You will probably prefer to use AFTER, rather than this command.

{{THE ORDER OF QUALIFIERS}
If you have defined three qualifiers, the UniLab looks first for
Q3, then for Q2 and lastly for Q1.  It must see the qualifying
events one immediately after the other.  If it does not see one
of them, it starts searching for Q3 again.

Of course, if there are only two qualifiers, then the UniLab
looks for Q2 and Q1.  

{{AFTER THE QUALIFIERS}
Unless PEVENTS or PCYCLES has been set, the UniLab will
immediately start searching for the trigger after it finds the
last qualifier.  OF course, the trigger event does not have to
follow immediately after the last qualifier.


{{EXAMPLE

2 QUALIFIERS   S }
changes the number of qualifiers, so that the third one is
ignored.

~RB`<address>  RB

Resumes executing program, with a breakpoint set at indicated
address.  Must be used with RESET to establish debug control.

{{USAGE}
The first breakpoint must be in emulated ROM, and come after the
stack pointer has been initialized.  If your program does not
initialize the stack pointer, then you cannot set a breakpoint. 
However, setting up the stack pointer usually only takes three or
four bytes.

You can also use NMI or RI and SI to establish debug control.

{{MISSED BREAKPOINTS}
If the breakpoint is not reached, then the program will continue
to run until you press any key.  You must then use RESET
<address> RB to gain debug control.  You can only set a
breakpoint on the address of the first byte of an instruction. 

After a missed breakpoint the UniLab will try to achieve debug
control by asserting NMI.

Make certain that the address you try to set a breakpoint on gets
executed by the program--  set an analyzer trigger on the same
address with 
NORMT <address> AS.  

And make sure that your program does initialize the stack pointer
to point at RAM.  DEBUG uses the stack to save the state of your
system.


{{EXAMPLES

RESET 123 RB }
enables reset, and then restarts the target system with a
breakpoint set at address 123



{1007 RB}
without restarting the target system, run the program with a
breakpoint set at address 1007.


{{COMMENTS}
The second example above will work only if you have already
established DEBUG control.  

The first example will establish DEBUG control, as will an NMI
command.  RESET does not restart your target board-- it enables
the "reset" flag, so that the S or RB which follows restarts the
target.
~READ`no parameters

Narrows the trigger specification to read cycles only.

{{USAGE}
Instructs the UniLab to trigger only on read cycles.  Handy when
you want to trigger on data memory values, not program memory
opcodes.  Or, when you want to trigger on reads rather than
writes to some address range.

On some disassembler packages, FETCH instructs the UniLab to
trigger only on fetches from program memory.


{{EXAMPLES

READ 13 DATA }
sets up to trigger when microprocessor reads a 13.

{NORMT READ 1000 TO 2000 ADR S}
triggers when processor reads any data from address range 1000H
to 2000H.                                   

{{COMMENTS}
A simple macro which specifies a range of CONT input values. This
command, like WRITE and FETCH, gets defined for a particular
processor by the optional disassembler.
~RES`<n> RES

Clears bit n of the stimulus generator output.  The number, of
course, must be between 0 and 7.

{{USAGE}
Simulates a peripheral input going from voltage high to voltage
low.  The stimulus generator allows you to test how your system
responds to digital signals on certain lines.


{{EXAMPLES

2 RES}
resets output S2.

{1 SET  1 RES }
pulses output S1.  


{{COMMENTS}
Used to reset individual bits of the 8 stimulus outputs. See also
SET and STIMULUS.

~RES-`RES- <memory command>      SHIFT-F9

Pulls the RES- output of the UniLab low and holds it low until
the analyzer is started.  This is one way to prevent your target
processor from having problems when you read or write emulation
memory.

{{USAGE}
You can use this command with some target systems to hold the
target processor in a reset state, before you access emulation
memory.  Otherwise, while you access emulation memory the target
microprocessor will see only FFs when it tries to fetch from
emulation memory (that is, all the data lines high).  Some
processors will quietly vector to an error-handling address when
this happens, but other processors might "go south," taking
peripheral devices and battery backup RAM with them when they go.

RES- will cause your target processor to reset, regardless of
whether you have reset enabled or disabled.

RES- will not work if your target system has a "one-shot" in the
reset circuit.

{{ALTERNATE SOLUTION}
There is a more general solution to the same problem: establish
DEBUG control before you access emulation memory.  That way, your
processor will be held in the idle loop while you access
emulation ROM.


{{EXAMPLES

RES- 10 DN}
pulls the reset line low and then disassembles from memory,
starting at address 10.  Reset will stay low until the next time
you start the analyzer.

{RES- 500 ASM}
pulls the reset line low, then invokes the assembler, starting at
address 500. 
~RESET`no parameters       F8

Selects automatic reset mode, which resets the target system when
you next start the analyzer.

{{USAGE}
Along with RESET', allows you to choose whether to restart the
target board when you start searching for a trigger, or just
watch a program already in operation.

To gain DEBUG control with RB you must enable reset. Always type
RESET <address> RB to be sure.

Automatic reset gets turned on by STARTUP, and gets turned off by
NOW, ADR?, SAMP, and RB.  The status of reset is not affected by
NORMx.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.


{{EXAMPLE

RESET}
selects auto-reset 

~RESET'`no parameters       F8

Turns off the automatic reset mode. See RESET above.

{{USAGE}
Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~RI`RI  <trigger spec> SI 

Allows you to gain DEBUG control on any bus condition.

{{USAGE}
To gain debug control on a data value, or a control column value,
or a range of address values.  Always used in combination with
SI.  RI marks the beginning of the trigger specification, SI
marks the end.

When the bus state you specify occurs this sophisticated feature
asserts an NMI signal.  Generally, it takes one or two
instructions cycles to gain debug control.


{{EXAMPLES

RI 450 TO 470 ADR SI}
Will achieve DEBUG control after any address in the range 450 to
470 appears on the bus.

{RI WRITE  34 DATA SI}
Will achieve DEBUG control after the value 34 is written into
RAM.

~RMBP`<break point #> RMBP

Resets (clears) one of the multiple breakpoints and displays new
status of the multiple breakpoints.

{{USAGE}
When you want to get rid of one of the breakpoints that you set
with SMBP.

See also CLRMBP, which clears out all the multiple breakpoints.


{{EXAMPLE

3  RMBP  }
clears multiple breakpoint number 3.


{{COMMENTS}
Multiple breakpoints are used with to break on more than one
address.  There are 8 multiple breakpoints available in addition
to the standard (unnumbered) breakpoint set by RB or  GB.  

~RSP`no parameters       F8

Re-enables DEBUG, after it has been disabled by RSP' or EMCLR.

{{USAGE}
Only when you have turned off the DEBUG features, and now want to
be able to use it again.  Not the same as establishing debug
control, which you do with NMI or RB.  However, if you have
disabled the DEBUG, then you cannot use either of those commands.

Normally you will use the MODE panel (function key 8) when you
want to enable or disable this feature.
~RSP'`no parameters       F8

Turns off DEBUG features.

{{USAGE}
Enables complete transparency-- no emulation memory is affected
by the UniLab operation. 

DEBUG is disabled for you by EMCLR.

{{RESERVED AREA}
Allows you to use for your program the areas that Orion otherwise
reserves for DEBUG vectors and overlays.   Press CTRL-F3 to get a
help screen that includes information telling you where the
reserved bytes are for your processor.

{{MODE PANEL}
You will not be able to use the DEBUG features until you turn
them on again from the MODE panel, or with RSP.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~RZ`no parameters

Resume program from breakpoint, without any breakpoints set. 
Debug control will be lost.

{{USAGE}
When you want to run the program starting from the current
address. 

A handy command for exiting from DEBUG control.  However, a
better command is GW which waits until you start the analyzer, so
that you can start the program from the breakpoint with a trigger
set.


{{EXAMPLE

RZ}
Continues the program after a breakpoint.


{{COMMENTS}
Don't try to specify a trigger event before RZ-- it will not
work.

~S`no parameters
                    
Starts the bus state analyzer.  Resets the target system if
automatic RESET is enabled.  

{{USAGE}
You do not need to start the analyzer on the same line as the
command that sets up the trigger event specification, though that
is the usual practice.  
S is a separate command that gets the analyzer going with
whatever spec you created already in place.

You can use TSTAT to see what the trigger has been set up to
(Trigger STATus).


{{EXAMPLES

S}
Starts the analyzer, with whatever trigger was last defined.

{NORMT RESET 123 ADR S }
clears out the trigger spec, turns on auto-reset, and then sets
it to address = 123 before starting the analyzer (and restarting
the target board).
~S+`no parameters

Identical to S, except that it increases the delay cycle count 
by A6 counts.

{{USAGE}
Handiest when you find that your current trace just starts
getting interesting at the end.  S+ by itself will trigger on the
same event, but with a new trace window that starts 3 cycles
before the end of the previous one.  

You should use this when your trigger spec is an event that gets
regularly repeated during the program, or with RESET enabled. 
All S+ does is change the value of DCYCLES and then start the
analyzer again.

So if your trigger spec only happens once in the program, and
RESET is disabled, then the UniLab will be searching a program in
progress for an event that has already occurred. 


{{EXAMPLE

S+ }
restarts the analyzer with an increased  delay setting.

~SAMP`no parameters

Samples the 48 input lines several times a second, and displays
them until any key is pressed.

{{USAGE}
A good way to get a vague idea of what is going on.  It will be
clear to you that the program has been stuck in an infinite loop,
or that it has gone far astray.  But you will not be able to tell
much, as you only see one cycle out of every several thousand.

{{DISASSEMBLY}
You will probably want to turn off the disassembler, with the
Mode Panel (F8) or DASM'.  When the disassembler is enabled the
isolated cycles will probably be disassembled incorrectly. 


{{EXAMPLE

SAMP}
This command never used in combination with anything else.       
                  


{{COMMENTS}
Useful when you are trying to connect analyzer inputs to
something and you want to continuously monitor their state. 
Similar to 1 SR but it runs faster.  Gives more detail on program
execution than ADR?.  Don't forget to start from scratch on
trigger specs after using SAMP, because it defines its own
trigger.  

It also turns off the RESET. 

~SAVE-SYS`SAVE-SYS <file name>

Saves the entire UniLab system program in its present state as a
named DOS file.  Prompts you for file name if you do not include
it on command line.

{{USAGE}
To save a version of the system with new macros, or with default
drives changed.  Or, just to save the current emulator enable
values, the current trace, and the trigger definition.

Warning-- does not save the symbol table.  Do that with SYMSAVE
command.


{{EXAMPLE

SAVE-SYS B:NEWUL}
Saves the system to a new file on the B: drive.


{{COMMENTS}
The target program, which is in the UniLab itself, is not saved
by this command.  Use BINSAVE.

This command automatically makes the "file extension" .COM.

Since the entire program image is saved including any
unintentional damage to the program, always keep backup copies.
~SC`<count> SC <file name>

Starts the analyzer and waits the specified maximum number of
milliseconds for trigger.  When trigger occurs, the trace gets
compared to a previously saved trace.

{{USAGE}
Very useful when writing test programs that compare the trace to
a known good trace that you have stored away.  Save traces with
the TSAVE command.  If a trace does not match, the host computer
beeps and displays both a section of the previous trace and the
first bad step of the new trace. 

{{HARDWARE CHECKOUT}
Probably most useful for hardware checkout.  To get a vague idea
of the capabilities, save a trace right now (TSAVE test). Then
pull the RAM off your target board and execute the command below.

Don't change your trigger spec between saving the good trace and
getting the new one.  See Appendix F for examples.


{{EXAMPLE

test 400 SC}
Starts the analyzer board with a 400H ms trigger time limit (1
sec.) and compares the trace to the one saved in file "test."


{{COMMENTS}
If the time limit passes with no trigger, the host displays a 
"NO TRIGGER" message and beeps. 

~SET`<n> SET

Sets bit n of the stimulus generator output.  The number, of
course, must be between 0 and 7.

{{USAGE}
Simulates a peripheral input going from voltage low to voltage
high. The stimulus generator allows you to test how your system
responds to digital signals on certain lines.

{{EXAMPLES

7 SET}
sets stimulus output 7.

{1 SET  1 RES }
pulses output S1.  


{{COMMENTS}
Used to set individual bits of the 8 stimulus outputs. See also
RES and STIMULUS.
~SET-COLOR`no parameters

Change the display colors for a color monitor.

{{USAGE}
After you have issued the command COLOR to inform the UniLab
software that you have a color monitor, you can change the
display colors with this command.  

You use the cursor keys to choose different colors, and see them
displayed as you choose.  Press the END key on the numeric key
pad when you have completed your choices.  You will need to save
the system with 
SAVE-SYS if you want the colors to be permanent.

~SET-GRAPH-COLOR`     no parameters            PPA

Change the display colors of the graph generated by the optional
Program Performance Analyzer option (AHIST and THIST).  This is
only appropriate for a color monitor.

{{USAGE}
After you have issued the command COLOR to inform the UniLab
software that you have a color monitor, you can change the
display colors of the histogram portion of the AHIST and THIST
display screens with this command.  
You use the cursor keys to choose different colors, and see them
displayed as you choose.  Press the END key on the numeric key
pad when you have completed your choices.  You will need to save
the system with 
SAVE-SYS if you want the colors to be permanent.

~SHIFT-FKEY`<# of key> SHIFT-FKEY  <command>

Assigns a command to a function key pressed while the SHIFT key
is held down.

{{USAGE}
Reassign the function keys on PCs and PC look-alikes.  Use
SHIFT-FKEY? (or SHIFT-F1) to find the current assignments.
     
The function keys allow you to execute any command or string of
commands with a single keystroke.  The initial assignments
represent our best guess at what you will need.  But you might
want to change them.

To make your reassignments permanent, use        SAVE-SYS. 


{{EXAMPLE

6 SHIFT-FKEY  TSTAT}
assigns TSTAT to SHIFT-F6.


{{COMMENTS}
To execute a string of commands, define a macro first (using : )
and then assign the macro to the function key.  

See also FKEY, CTRL-FKEY, and ALT-FKEY.
~SHIFT-FKEY?`no parameters       SHIFT-F1

Displays the current assignments of the SHIFTed function keys.

{{USAGE}
Whenever you want to be reminded what command will be executed
when you press a function key while holding down the shift key.

See SHIFT-FKEY to reassign the keys.
~SHOWC`no parameters       F8

Shows the control lines on the trace display (the default
condition).

{{USAGE}
Turn on display of the control lines, C7 through C4, as well as
the high four bits of the address bus, A19 through A16.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.





~SHOWC'`no parameters       F8

Turns off display of the control lines on the trace display.

{{USAGE}
Turn off display of the control lines, C7 through C4, as well as
the high four bits of the address bus, A19 through A16.

Though the UniLab must always monitor these wires, and sometimes
they give you vital information (such as that you have the wires
hooked up wrong), usually you don't need to see them.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~SHOWM`no parameters       F8

Shows the miscellaneous lines and the HDATA lines on the trace
display (the default condition).

{{USAGE}
Turn back on display of the miscellaneous lines and the high data
lines (on 8 bit processors).  

You will want to see these lines when you have them hooked up to
your board.  Otherwise, you can ignore them.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.





~SHOWM'`no parameters       F8

Hides the miscellaneous lines and the HDATA lines on the trace
display (the default condition).

{{USAGE}
Turn off display of the miscellaneous lines and the high data
lines (on 8-bit processors).  

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~SI`RI  <trigger spec> SI 

Allows you to gain DEBUG control on any bus condition.

{{USAGE}
Always used in combination with RI.  Please consult the reference
section on RI.

~SMBP`<addr>  <breakpoint #> SMBP

Sets one of the 8 multiple breakpoints at the given address.

{{USAGE}
Allows setting of up to 8 breakpoints, in addition to the
unnumbered breakpoint that is set by RB or GB.  The status of all
8 breakpoints gets displayed each time you set or clear one.  

You must already have debug control before you issue this
command.

To use multiple breakpoints, set all but one of your breakpoints
with this command, and then use RB or GB to get the target
program going again.



{{EXAMPLES

123 4  SMBP}
          sets a breakpoint #4 at address 123.

250 RB}
sets a breakpoint at 250 and starts the target program going
again.

{{COMMENTS}
See also N, CLRMBP, RMBP.

Before using multiple breakpoints, you should examine the
possibility of using the more powerful capabilities of the
analyzer to do the same thing.
~SOFT`SOFT <filename>          PPA

Enables the optional Program Performance Analyzer for the new
command file that it creates.  Need by used only once.  Prompts
you for the filename if you do not include it on the command
line.

{{USAGE}
Reconfigures your software, so that you can use the Program
Performance Analyzer commands AHIST, MHIST, THIST, HSAVE, HLOAD,
and SET-GRAPH-COLOR.

Do not use SOFT until after you have copied the HISTxxx.OVL file
into your ORION directory.


{{EXAMPLE

SOFT ppaZ80}
Creates a new .EXE file, PPAZ80, which will recognize the Program
Performance Analyzer commands.

~SOURCE`No parameters

Re-enables the display of source code interleaved with
disassembly of machine code.  SOURCE is automatically enabled
when you load a .MAP file in with MAPSYM.

{{USAGE}
It is necessary to use this command only after you have disabled
the high-level support feature with SOURCE'.  

{{ABOUT HIGH-LEVEL SUPPORT}
Orion high level support shows you the line of your source code
which generated your assembly code.  To use this feature, you
must load your .MAP file with MAPSYM and have the relevant source
files in the current directory.  

See MAPSYM for more information.

~SOURCE'`no parameters

Turns off the display of source code.  See SOURCE.
~SPLIT`no parameters       F2

Toggles split screen mode on and off.

{{USAGE}
Gives you the ability to compare traces, or parts of the same
trace.  You can also compare a trace to the assembly code (DN),
or to your source text file (TEXTFILE).

{{WHAT WINDOWS ARE FOR}
The right quadrants are reserved for the output of DN, and for
the pop-up panels (MODE).  TEXTFILE only works in the top window.

Help screens are always shown in the top window.

{{MOVING AROUND}
The END key moves you from one window to the other.

{{HISTORY}
The history mechanism, which saves a record of what has happened
during your session with the UniLab, only records information off
of the bottom screen.

{{EXAMPLES

SPLIT}
This command never used in combination with anything else. 

~SR`<n>  SR

ReStarts the analyzer Repeatedly. Displays n lines each time
trigger occurs.

{{USAGE}
Very useful for logging things repeatedly.  You should first set
up the trigger and starting point of the display with S and TN.  

{{STOPPING}
You start the infinite loop by entering SR.   You break out by
pressing any key.

{{HARD COPY}
Use the Mode Panel (F8) or PRINT to log your output to the
printer.  The Mode panel also contains a feature that allows you
to log to a file.  See TOFILE.

{{RESETTING OR INTERRUPTING THE TARGET}
If you use RESET, then the target system will be reset each time
the analyzer starts.  

{{WHEN TO USE SOMETHING ELSE}
If the events you want to see occur more often than once per
second and you want to see them in sequence, you can use  XAFTER
along with A9 SR to log bursts of the events in filtered format.


{{EXAMPLES

20 SR}
Repeatedly displays twenty lines of trace buffer, starting the
analyzer again after each display.
~SSAVE`SSAVE <filename>    ALT-F9

Saves the screen image as a DOS text file.

{{USAGE}
Save the image of a graph generated by the Program Performance
Analyzer option, or save any other screen image that you want.


{{EXAMPLE

SSAVE  nice.scr}
Saves the current screen as a file, nice.scr.

~SST`<trigger spec> SST

Starts the analyzer in the standalone mode.

{{USAGE}
Set the analyzer looking for a bug that you think will take a
while to find.  After you issue this command, you can disconnect
the UniLab from your host, or you can keep it plugged in but exit
from the UniLab program (BYE).

Either way, the LED on the UniLab goes out when it finds the
trigger.  You then plug in the UniLab again, call up the UniLab
program, and enter TS to display the trace.


{{EXAMPLE

NORMB 1200 TO 1300 ADR WRITE 3F TO FF DATA SST}
Searches for this trigger in standalone mode.


{{COMMENTS}
Handy when you want to search for an obscure bug without tying up
the host computer.  
~SSTEP`no longer available

The functionality of this command is now assigned to the new
"smart" NMI.  NMI now achieves DEBUG control for you, or executes
one instruction if you already have DEBUG control.  See also N.

~STANDALONE`STANDALONE <prom programming command>

Selects the standalone mode for the EPROM programming command
that follows.

{{USAGE}
Allows you to use the host computer for something else while the
UniLab programs an EPROM.  Especially handy when programming
large EPROMs.  

You can type in STANDALONE and press return, then use the PROM
programming menu to program the EPROM.

When the LED next to the PROM programming socket goes out, the
command has been completed.  You can then enter PROMMSG to get
the completion status message.  The UniLab must remain connected
to the host computer, or you will not be able to get the message.


{{EXAMPLES

STANDALONE}
use this command and then make use of the convenient PROM
programming menu to burn an EPROM in standalone mode.

{STANDALONE  0 TO 1FFF P2764}
you can also use STANDALONE along with a PROM burning command, if
you know the commands.

~STARTUP`no parameters       F9

Restarts the target system and gives a trace of the first 170
cycles of target system operation.

{{USAGE}
Very useful mode at the first stages of system checkout.   Allows
you to check out the first few instructions, make certain that
they execute properly. 

The RES- wire from the analyzer cable must be properly connected
to the target system, or the UniLab will not be able to reset the
target processor.  See the Installation chapter of the User
Manual.  

The very first cycle (cycle 0) is particularly important because
if correct data is not fetched (often due to the address not
being properly EMENABLEd), then the program will immediately
"blow up."  

{{MULTIPLE RESET}
Some systems with simple R-C reset circuits (no hysteresis) will
appear to reset intermittently many times before they finally
settle down to stable operation.  This is a nuisance if you want
to look at a trace early in the program, but you will be able to
see the program when it does finally settle down. 

If your system does this, you might want to consider putting a
logic element-- such as two Schmitt triggers in a row (part
number LS14)-- into your reset circuit.  That way your system
will always get a good strong reset signal.

{{EXAMPLES

STARTUP}
This command never used in combination with anything else. 

{COMMENTS}
This is a target specific macro that usually looks for the reset
vector address on the bus.  If that address does not show up,
system will wait forever.  Or if a HALT instruction is fetched,
will give a "NO ANALYZER CLOCK" message.  See TroubleShooting
chapter.
~STIMULUS`<byte> STIMULUS

Changes the 8 stimulus outputs (S0-S7) to correspond to the
specified byte.  Also pulses the ST- output.


{{EXAMPLE

10 STIMULUS }
makes all stimulus outputs zero, except S4


{{COMMENTS}
Useful for changing all stimulus outputs at once.  Use SET or RES
to set and reset individual signals.  The stimulus outputs
originate in the PROM socket on the front of the UniLab and are
normally connected by the stimulus cable provided with your
system.  The stimulus signals are usually used to provide test
inputs for the target system.
~SYMB`no parameters       F8

Enables the symbol translation feature.

{{USAGE}
Turns symbol translation back on, after it has been disabled with
SYMB'.   Symbols make the trace more readable, by allowing you to
replace data and addresses with symbolic names.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

Symbols are entered by using IS or SYMFILE, either of which will
turn on symbol translation.





~SYMB'`no parameters       F8

Disables the symbol translation feature.

{{USAGE}
To turn symbol translation off without clearing out the symbol
table.  See CLRSYM if you want to clear out the table.

Normally you will use the MODE panel (function key 8) when you
want to change this feature.

~SYMDEL` <number> SYMDEL

Allows you to remove one symbol from the current symbol table. 

{{USAGE}
Use SYMLIST first to get a list of all the symbols in order of
increasing value.  This list of symbols is numbered.  You delete
a symbol by using its number, not its value.

{{EXAMPLE

5 SYMDEL}
Deletes the fifth symbol in the list that SYMLIST shows you.
~SYMFILE`SYMFILE <file name>

Loads a symbol table file produced by a cross assembler . Prompts
for a file name if you don't include it on command line.

{{USAGE}
Capable of loading symbol tables in almost any format.  The first
time you use it, SYMFILE presents you with a menu of predefined
formats.  You can choose one of those, and then save the system
with SAVE-SYS to make that the default format.

You can change the default format with SYMTYPE or with SYMSET.

Formats not on the menu can be defined using SYMFIX for fixed
length files.  Variable length files only come in two formats: 
name and then value, or value and then name.  

The AVOCET format on the menu is for symbol files that are name,
then value.  

The MANX format on the menu is for symbol files that are value,
then name.
          
The MICROTEK format refers to "MicroTek/New Micro,"  not to
"Microtec Research."   Symbol files with this format are produced
by the 2500AD cross-assemblers, and include local symbols.  


{{EXAMPLES

SYMFILE C:\ASM\OUT.SYM}
Loads into the UniLab a symbol file created by an assembler.
~SYMFILE+`SYMFILE+ <file name>

Appends the contents of a symbol file to the symbol table.

{{USAGE}
Provides a way of adding to a symbol table that already exists. 
SYMFILE, on the other hand, automatically clears the existing
symbol table.

SYMFILE+ allows you to combine several symbol tables.

See also CLRSYM.


{{EXAMPLES

SYMFILE+ A:EXTRA.SYM}
Adds to the symbol table the symbols stored in a file on the A
drive.

~SYMFIX`<a> <b> <c> <d> <e> <f>  SYMFIX

Defines symbol file parameters for formats that use fixed length
records.  

{{USAGE}
Use this word to define your own SYMFILE format for fixed length
records, if none of the predefined formats available on the
SYMFILE menu suit your purposes.  There are only two types of
variable length record formats (value then name or name then
value) and both appear in the menu.

The definitions of the 6 parameters:

     a = offset from start of record to start of name field.
     b = 1 if address is 4 ASCII digits or 0 if 16-bit binary.
     c = address field offset from start of record. 
d = 1 if binary address has most significant byte  first.
     e = pad characters used to fill between symbols.
     f = record length.


{{EXAMPLES

0 0 B 1 0 E SYMFIX  }
defines the format for 2500AD abbreviated symbol table files.
These tables follow the format:
ten bytes for the symbol name,
two bytes for the symbol value,
two pad bytes.
~SYMLIST`no parameters

Shows you a numerically ordered list of all currently defined
symbols.

{{USAGE}
To verify that your symbol file has successfully loaded in, or to
remind yourself which symbols you have defined with IS.  

This command also gives you the information that you need to
selectively delete symbols.  See SYMDEL.


{{EXAMPLE

SYMLIST}
Lists all the current symbols.
~SYMLOAD`SYMLOAD <file name>

Loads a UniLab format symbol table file from the disk.  Prompts
for you for file name if you don't include it on command line.

{{USAGE}
Loads up a symbol table that was saved with SYMSAVE.

These files are variable length, allowing symbols up to 255
characters long.  

Warning:  not compatible with symbol tables saved with pre-
version 3.0 SYMSAVE.


{{EXAMPLE

SYMLOAD B:oldsyms}
Loads into the UniLab a symbol table file from the B drive.

~SYMSAVE`SYMSAVE <file name>

Saves the symbol table as a named DOS file.  Prompts for file
name.

{{USAGE}
This command saves only the symbol table, which you will be able
to load in later with SYMLOAD.

Use SAVE-SYS to save the entire system.


{{EXAMPLE

SYMSAVE july3.sym}
Saves the current symbol table to a file called july3.sym.
~SYMSET`<n> SYMSET         Macro Sys
Chooses the symbol file formats that SYMFILE will expect.
For use within macros.

{{USAGE}
Usually, before loading in a symbol file, you will use
SYMTYPE to choose the format from an interactive menu. 

However, if you want to "hard code" a format in a
macro, you need to use SYMSET. 
The syntax is <n> SYMSET, where <n> is a number
corresponding to these symbol types:

     1   2500AD SOFTWARE
     2   2500AD SOFTWARE      (abbreviated)
     3   ALLEN ASHLEY
     4   INTEL ISIS-II (MCS-51 only )
     5   MICROTEK FORMAT     
     6   Don't use-- use SYMFIX instead.
     7   MANX AZTEC C    (value, variable length name)
     8   AVOCET          (variable length name, value)

{{EXAMPLE

7 SYMSET}
The equivalent of option seven on the SYMTYPE
menu.  SYMFILE will now expect a symbol file with,
on each line, a value followed by a variable
length name.

~SYMTYPE`no parameters

Re-defines the file format assumed by the SYMFILE command.

{{USAGE}
Presents you with the symbol table format menu.  This allows you
to choose a different format after you have chosen one with
SYMFILE.  For setting a format in a macro, see SYMSET.

The first time you use the SYMFILE command you are presented with
a menu of formats.  Once you have chosen a format, SYMFILE
executes immediately, using the selected format.  SYMTYPE allows
you to alter your choice of format.

See also SYMFIX.

The MICROTEK format in the menu refers to "MicroTek/New Micro," 
not to "Microtec Research."

{{EXAMPLE

SYMTYPE}
This command never used in combination with anything else. 
~T`no parameters                

Displays the trace from its current starting point until any key
is pressed.


{{EXAMPLE

T}
displays the trace.


{{COMMENTS}
The current starting point for the trace display is defined by
the most recent TN command.  (STARTUP usually sets it to -4.)

If the starting cycle # is not actually in the trace buffer, the
trace is started 4 lines from the closest cycle number which is
in the trace buffer.  

~TCOMP`<n> TCOMP <file name>

Compares the present trace buffer to a previously stored trace in
the named file.  Compares the last <n> cycles.  Aborts and
indicates error if any bit fails to compare.

{{USAGE}
Very useful for writing automatic system test programs.  Use the
value AA to compare the entire trace.
 
Use TSAVE to save the trace of a good system.  You can then use
that saved trace to test other systems.  

If TCOMP finds a difference between the current trace and the one
in the file, it will display 9 lines of the stored trace and the
first bad line in the trace of the system under test.

You can use TMASK to tell TCOMP to ignore one or more of the
columns in the trace display.  See TMASK for details.

You can also use SC to compare traces.


{{EXAMPLE

AA TCOMP march.2 }
 compares the entire trace to the one stored as file "march.2."


{{COMMENTS}
If you want to compare only part of the trace, use a smaller
number.  TCOMP  will then skip over the first part of the file. 
This is useful for skipping over the already known discrepancies
between two traces.

If TCOMP behaves in a confusing manner, try using it with the
disassembler disabled (DASM' or use the mode panel, F8).
~TD`no parameters

Stops the analyzer and displays the current contents of the trace
buffer.

{{USAGE}
To see what is going on, when trigger has not occurred, or when
you are producing a filtered trace that you do not think will
fill up the trace buffer.  Normally the trace is automatically
uploaded to the host when trigger occurs.

TD skips over the first cycle in the buffer, and any other empty
space (all 1's) at the top of the buffer.


{{EXAMPLE

TD}
This command never used in combination with anything else. 


{{COMMENTS}
Since the buffer is filled with 1's before the analyzer is
started, a partially filled filtered trace buffer will have good
data only near the end.  TD automatically skips over the empty
space.
~TEXTFILE`TEXTFILE <filename>

Allows you to look over a text file from within the UniLab
program.

{{USAGE}
TEXTFILE only works from the upper window.  It will take a few
seconds to analyze the file, and then will show you the first
window full of text.  

This feature is useful for looking at your source code while you
debug it-- this could replace hard copy listings.

{{MOVING AROUND THE FILE}
Use the PgDn key or the Down Arrow to see more of the text.  The
PgUp key scrolls the screen back, the Up Arrow moves you up one
line.  Use <line#> TX to move to a specific line number in the
file.

The HOME key takes you back up to the top.  The END key just
toggles you to the lower window.

{{WATCH OUT}
You can't alter the file in any way-- only look it over.


{{EXAMPLE

TEXTFILE \memo\project1}
Opens the DOS file project1, in a directory called memo.

~THIST`no parameters            PPA

Time HISTogram invokes the optional Program Performance Analyzer
(PPA) that allows you to display how often the elapsed time
between two addresses falls into each of up to 15 user-specified
time periods.  See also AHIST and MHIST.

{{USAGE}
Allows you to examine the performance of your software.  You can
find out how the elapsed time between any two addresses changes,
as different conditional jumps or branches are taken.

To get interesting and useful results, you will probably want to
measure the time between two addresses in your main loop. 

Press F10 to exit from this command.

You must (only once) issue the command SOFT to enable this
optional feature.  SOFT performs a SAVE-SYS, and then causes an
exit to DOS.  The next time you call up the software, the PPA
will be enabled.

{{MENU DRIVEN}
You produce a histogram by first specifying the upper and lower
limits of each time "bin" that you want displayed (F9), then
starting the display (F1).

When you give the command THIST, you get the histogram screen
with the cursor positioned at the first bin.  You can then start
typing in the lower and upper limits of each bin.  Use return,
tab, or an arrow key after you enter each number, to move to the
next entry field.

Press function key 1 (F1) to start displaying the histogram.

{{SAVE TO A FILE}
You can save the setup of a histogram as a file with the HSAVE
<file>.  Issue this command after you exit from the histogram.

You load the histogram back in with HLOAD <file>.  This command
also invokes the histogram.

~TMASK`<byte value> TMASK

Set up a mask which tells TCOMP which columns to compare.

{{USAGE}
The lower six bits of the byte value tell TCOMP which groupings
of the trace display to use when comparing traces.  The default
is 3F (00111111 binary) which tells TCOMP to check all columns.

Used when comparing traces to filter out erroneous error
messages-- due, for example, to different wiring of the MISC
lines.

{{MASK VALUES}
Each of the six bits corresponds to one of the groupings.  If the
bit is one, then TCOMP will include that grouping:

               BINARY      GROUPING     HEXADECIMAL

               0000 0001   LADR         1
               0000 0010   HADR         2
               0000 0100   CONT         4 
               0000 1000   DATA         8 
               0001 0000   HDATA       10  
               0010 0000   MISC        20

~TN`<n> TN

Displays the trace buffer, starting at cycle n.  Sets the
starting point for future trace displays.

{{USAGE}
For random access to the trace buffer, when you also want to
reset the starting point used by T. To access the buffer without
changing the default value of the point where the display starts,
use TNT.


{{EXAMPLE

12 TN }
Displays the trace, starting 12 cycles after the trigger.  The
rest of the traces this session will also be initially displayed
starting 12 cycles after the trigger.


{{COMMENTS}
You will usually want to use TNT.  Use TN when you think that you
will want to display from the same point on future trace
displays.
~TNT`<n> TNT

Displays the trace buffer, starting at cycle n.

{{USAGE}
Allows you to immediately look at any point in the trace buffer. 
TN does the same thing, but also changes the default trace
starting point used by T.  The default trace starting point is
set to -5, until you change it.


{{EXAMPLE

-7 TN }
displays the trace starting 7 cycles before the trigger.  
~TO`<number> TO <number> <command>

Sets a flag that indicates that a range of numbers is being
entered.

{{USAGE}
Used with all of the trigger event description commands to define
a trigger on a range of numbers.  See ADR, CONT, DATA, HADR,
HDATA, LADR, and MISC.


{{EXAMPLE

12 TO 34 DATA }
Tells the analyzer to look for any data on the range 12 to 34 on
the data inputs.


{{COMMENTS}
In the example above omitting the TO would result in a trigger
spec that would accept only data = 34.  

~TOFILE`TOFILE <filename>   F8

Use to start sending screen output to a DOS textfile as well as
to screen.

{{USAGE}
Use for toggling on the logging of information to a file.  You
can include that command on the DOS command line as a "command
tail."  For example:

{{                C> ULZ80  TOFILE A:JUNE7.LOG}

The usual DOS rules for naming files apply.

You will be prompted for the file name if you do not include it.

Turn off logging to the file with TOFILE'.

You can use the MODE panel (function key 8) to toggle logging to
a file on and off, but you have to use the command to open the
file in the first place.

{{COMMENTS}
Files produced in this way can then be edited with a word
processor, or shown on the screen using the DOS command:   TYPE
file name.
~TOFILE'`no parameters       F8

Use to stop sending screen output to DOS textfile as well as to
screen.

{{USAGE}
Use for toggling off the logging of information to a file. 

Normally you will use the MODE panel (function key 8) when you
want to change this feature.
~TOP/BOT`no parameters       END key

Moves you from top window to bottom, or from bottom window to
top.

{{USAGE}
You will usually want to just use the END key, which is the
number one key of the numeric key pad.

Only active when the screen has been split with SPLIT (function
key 2).  See that word for details about windows.


{{EXAMPLE

TOP/BOT}
This command never used in combination with anything else. 

~TRAM`no parameters

Turns off a flag, so that subsequent memory reference commands
refer to RAM rather than ROM.  Necessary only with processors
that allow ROM and RAM to occupy the same address space, or that
address more than one 64K segment of memory.

{{USAGE}
Only needed when you want to refer to RAM that occupies the same
16 bit address space as ROM-- for example, with the 68000
microprocessor.

The flag stays reset until you use the command TRAM'.


{{EXAMPLE

TRAM  0 F MDUMP}
    Dumps the contents of RAM, from address 0 to F.


{{COMMENTS}
This command can sometimes get you into trouble-- if you use RB
after TRAM' you will be setting a breakpoint in RAM.  Which is
fine if you meant to set a breakpoint in RAM, but disastrous if
you meant to set the breakpoint in ROM.  
~TRAM'`no parameters

The default condition-- turns on a flag, so that subsequent
memory reference commands refer to ROM rather than RAM. 
Necessary only after TRAM, or similar processor-specific
commands.

{{USAGE}
Only needed after you use TRAM.


{{EXAMPLE

TRAM'  30 3F MDUMP}
    Dumps the contents of ROM, from address 30 to 3F.
~TRIG`TRIG  <event description>

The event description that follows will be a trigger event.

{{USAGE}
As opposed to Q1, Q2, and Q3, which tell the analyzer that the
following description is a qualifying event.  Useful if you want
to alter the trigger event without altering the qualifiers.

{{EXAMPLE

TRIG  123 ADR}
    searches for 123 on the address lines.


{{COMMENTS}
Used to select the TRIG truth table context again after AFTER,
Q1, Q2, or Q3 has caused another truth table to be selected. 
Useful if you want to change your mind about the trigger step
after you have just defined a qualifier.  The 4 truth tables are
Q3, Q2, Q1, and TRIG.

~TS`no parameters

Displays trace after standalone mode trigger.

{{USAGE}
To retrieve the trace from the UniLab's trace buffer, after you
start the analyzer in standalone mode with SST.

When you use SST to start the analyzer, you can disconnect your
host computer from the UniLab and run other programs on the
computer.  When the analyzer sees the trigger, the light next to
the analyzer goes out.  You can retrieve the trace at anytime
after that.

To retrieve the trace you must start up the UniLab program while
the UniLab is disconnected from the host.  Use CONTROL - BREAK to
break out of the Initializing UniLab... message.  Then reconnect
the UniLab and issue the TS command.


{{EXAMPLE

TS}
 This command never used in combination with anything else. 


{{COMMENTS}
TS begins by sending a "wake-up" code to the UniLab.  Since this
does not fit into the normal UniLab communications protocol,
don't enter TS unless you have previously entered SST.  If you
do, the system will hang.
~TSAVE`TSAVE <filename> 

Saves the current trace buffer as a file.

{{USAGE}
A good way to save information about a trace for later review
with TSHOW or for automatic comparison to another trace with
TCOMP or SC.


{{EXAMPLE

TSAVE good.trc}
saves current trace as a file called good.trc.
~TSHOW`TSHOW <file name> 

Displays a previously saved trace.

{{USAGE}
A useful way to examine traces saved while in the field, or by an
automatic testing program.  TSAVE saves the trace in the first
place.  

TCOMP will compare the present trace to the numbered trace, and
let you know if they differ.  That will probably, most of the
time, serve your purposes better than looking over a trace.


{{EXAMPLES

TSHOW good.trc}
Displays the trace saved by TSAVE into a file called good.trc .


{{COMMENTS}
If you are tracking down a problem you can save interesting
traces as you go so that you can look at them again later or even
print them out (by using control-P to turn on the printer).  

After you use TSHOW the trace image in the host contains the
recalled trace, so you can use T, TN, or TNT to view it from
various points.  

When you want to load the UniLab's trace buffer back into the
host, enter TD.  Since TSHOW changes the setting of DCYCLES, the
cycle numbers will be incorrect unless the changed delay setting
is the same as the previous one.
~TSTAT`no parameters       F7

Displays the complete status of the current trigger specification
including qualifiers, delay and pass counts filtering, and auto
reset.

{{USAGE}
A good way to determine what the current settings are. Also a
good way to check on how the UniLab interprets your trigger
specifications.


{{EXAMPLE

TSTAT}
 This command never used in combination with anything else. 
~TX`<line #>  TX     

Use with an open textfile to move to the specified line number of
the file.

{{USAGE}
A good way to quickly move around a textfile.  See TEXTFILE.


{{EXAMPLE

300 TX}
Moves to line 300 of the current open textfile. 

~WORDS`WORDS <command>

Displays an alphabetical listing of the UniLab's commands,
starting with the command or characters you include on the
command line.

{{USAGE}
To remind you of the names of some UniLab commands. Press any key
to stop the listing.  


{{EXAMPLE

WORDS  INIT }
shows a list of commands, starting with INIT.
~WSIZE`no parameters       SHIFT-F8

Allows you to redefine the size of the windows.

{{USAGE}
Once you enter this command, only the cursor keys are active. 
Use the "END" key (numeric pad key 1) to exit.

Use whenever you want to set the window size to something other
than the standard setup.


{{EXAMPLE

WSIZE}
This command never used in combination with anything else. 
