~16BIT`no parameters       Macro Sys  
   
Selects 16-bit mode for memory emulation, trace display, and PROM 
reading/writing.  
  
{{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       8420 Only 
  
Changes baud rate of serial port to 19,200 baud.  This is the  
default.  
  
{{USAGE}  
Use after 9.6K to restore the default condition.  
  
You must SAVE-SYS to make the change permanent.In order to 
communicate at 19,200 baud, the UniLab operating system 
communicates directly with the port hardware on the PC.  If you 
have non-standard serial I/O, you can reduce the baud rate to 
9600 and the UniLab operating system will use DOS calls to 
initialize and to send and receive data from the serial port of 
the PC. 
 
~1AFTER`1AFTER <trigger spec>             
Clears out previous trigger spec and enables trace filtering. The 
trace buffer will record only the bus cycle that satisfies the 
trigger spec and the one cycle immediately following. 
  
{{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 recorded.  
  
Use S to start the analyzer after setting the 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 the ESC key to stop the analyzer,  
then type T to display the data that has been collected.  
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 recorded after each  
trigger cycle.  
  
  
{{USAGE}  
Sets up the analyzer to record the trigger cycle and the two 
following cycles, every time it sees conditions that match the 
trigger specification.  
  
{{COMMENTS}  
See 1AFTER.  
  
 
~3AFTER`3AFTER <trigger spec>  
  
Same as 1AFTER, except that the three cycles after the trigger  
cycle get stored.  
  
{{COMMENTS}  
See 1AFTER.  Note that this filtered trace will contain  
enough information to make a disassembled trace sensible--  
sometimes.  
  
 
~8BIT`no parameters       Macro Sys  
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       8420 Only 
  
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.   
When this command is executed, the UniLab software uses DOS calls 
to communicate with the serial I/O port in the PC.  This command 
is often useful if you have non-standard serial communications 
hardware. See also 19.2K, for restoring the default.  
  
You must SAVE-SYS to make the change permanent.  
  
 
~:   (colon)` no parameters       Macro Sys  
    
The colon character starts a macro definition.  The word that  
follows the colon is the name of the macro.  
Use EDIT_MACROS (function key SHIFT-F10) instead to easily set up 
short (one-line) macros that are automatically assigned to the 
SHIFTed function keys. 
  
{{USAGE}  
Once a macro has been defined, you can execute any lengthy series  
of commands with a single word.  See the Reference Manual 
Appendix "Writing Macros" 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 Reference Manual Appendix "Writing Macros". 
 
~;  (semicolon)`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, 
otherwise, 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 <word>.  
  
  
{{USAGE}  
An example of the type of register control command available with  
a DEBUG package.  This command addresses the Z80 internal  
register BC.  Consult the Target Application Note for your 
processor-specific software for the commands that will alter your 
processor's registers. 
  
  
{{EXAMPLE  
  
1234  =BC }  
               puts 1234 in the BC register.  
  
  
{{COMMENTS}  
You can use the register commands only after your microprocessor 
is at a breakpoint.  See STEP-INTO or RB for more information on 
breakpoint. 
  
This is a typical register changing instruction format.  A  
similar command is provided for each of the processor's internal  
registers (except SP).   
No space appears between the  =  and the register name.   
{{ADVANCED USERS} 
The DEBUG software also includes commands which will get the 
value of any register while at a breakpoint.  These commands 
consist of the name of the register followed by a question mark.  
The command for the BC register is BC? .   
These commands prove to be valuable in macros.  For example, to 
disassemble the next 5 instructions, use this macro: 
: 5dm     pc? 5 dm ;  
See the Reference Manual Appendix "Writing Macros."   
Other DDBs have similar commands for each register: 
TO CHANGE REGISTER:                TO GET REGISTER: 
     =R1                                R1? 
     =X                                 X? 
     =DPTR                              DPTR? 
~=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 can also set this value from within the SET-EM panel. 
  
{{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.    
If you do need to change the value of EMSEG, you will find  SET- 
EM easier to use. 
  
{{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 is always set to some value by the processor-specific  
software package. 
  
On some microprocessors, those four lines are floating high, on  
other mp's several of the lines are pulled low.   And on those 
processors with more than 16 bits of address, these inputs to the 
UniLab are connected to the upper bits of the address bus. 
  
{{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}  
Tells the UniLab emulation memory to come onto  
the bus only when the upper four bits of the 20-bit  
address bus have the value 7 hex,  0111 binary. 
(A19 is 0 and A16, A17, and A18 are one.)  
  
 
~=HISTORY`<hex# of Kbytes> =HISTORY  
  
Selects the amount of room allocated for screen history  
during a 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 location of the area in emulation ROM used by the  
ORION DEBUG software.  
  
{{USAGE}  
When your software must use the default memory area reserved for 
the ORION DEBUG software, or when InSight requires a non-standard 
overlay location. 
When DEBUG is enabled (see RSP), the reserved area (only two 
bytes on most DDB packages) cannot contain user code.  The 
overlay area, above the reserved area, is used to swap DEBUG 
routines into memory.  Target program code can reside there and 
be executed, but DEBUG routines cannot be used on it. 
This command changes the location of both the overlay and the 
reserved area.  To find the current address of the reserved area 
use function key ALT-F1 to call up the HELP_DEBUG menu, and 
choose topic 1.  
  
You can also 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 must not cross a 2K boundary.  Be careful when  
changing its location.  
  
 
~=PORT`<address> =PORT       8620 Only 
  
Changes the address where the UniLab software expects to find the 
interface card.  Default address: 0220H. 
 
{{USAGE}  
Change the slot card's port address if you wish to connect 
multiple UniLab 8620s to your host computer, or if you have 
another peripheral device that uses the port addresses 0220H to 
023FH. 
Acceptable values for =PORT: 
     200  220  240  260  280  2A0  2C0  2E0. 
You will need to change the jumpers on P3 of the slot card  to 
reflect the change in address.  Refer to the UniLab 8620 hardware 
manual. 
  
You must SAVE-SYS to make the change permanent.  
  
  
{{EXAMPLES  
  
240  =PORT}  
Tells the software to look for the UniLab hardware 
at host port address 240.   
 
~=SAMP`<# of milliseconds> =SAMP      
  
Changes the delay between samples gathered with UniLab words  
SAMP and ADR?.  
Default: 100H milliseconds. (approx 1/4 sec.) 
{{USAGE}  
Change the length of the delay if you wish to see more  
or fewer samples per second.  Set it equal to zero for  
the fastest possible rate.  
You must SAVE-SYS to make the change permanent.  
  
  
{{EXAMPLES  
  
400  =SAMP}  
Slows the sample rate to approx. one per second  
(400H millisecond delay between samples).  
 
~=STROBE`<# of milliseconds> =STROBE       8620 Only 
Changes the length of the stimulus pulse from within the INSIGHT 
panel (see INSIGHT for more information).   
Default: 30H milliseconds. 
{{USAGE}  
Use this command if you wish to change the length of the  
stimulus pulse put out by INSIGHT. 
  
You must SAVE-SYS to make the change permanent.  
  
  
{{EXAMPLES  
  
200  =STROBE}  
Changes the stimulus strobe in the INSIGHT panel  
to be 200H milliseconds long. 
 
~=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 a working 
processor clock.  
  
{{USAGE}  
When you need a longer wait after reset for your target system  
to start functioning.  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 using 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  ALSO 1503 ADR }  
sets the analyzer to trigger when the address  
is 1200, 0008 or 1503.  Because of cross products,  
will also trigger on address 0003 and 1508.  
 
{{COMMENTS}  
AS is a convenient abbreviation for NORMT ADR S.   
ALSO must be used with caution with ADR. Generally you can use  
ALSO without cross-products if the high-order byte of the 
previous spec and the new one match.  You can instead specify the 
two bytes of the address separately using HADR and LADR.      
 
~ADR?`no parameters  
  
Displays random examples of the addresses seen on the bus--  
approximately ten every second.  
  
  
{{USAGE}  
This command displays ten 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 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 event.  
  
{{USAGE}  
When you have specified qualifying events, the UniLab will not  
search for the trigger until after the "qualifiers" have been  
seen.  
  
You can have up to three qualifying events.  Each qualifier spec  
must start with AFTER.    
  
The analyzer will only accept multiple qualifiers that 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   
  
{{EXAMPLES  
  
NORMT 100 ADR AFTER 535 ADR S }  
will trigger on address 100 anytime  
after address 535 is 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.  
See also FILES. 
  
You load the histogram back in with HLOAD <file>, or with the 
FILES dialog box.  Loading a histogram file 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.  
FKEY? (ALT-F1) shows 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 
EDIT_MACROS for information about easy macros.  
  
See also FKEY, and CTRL-FKEY. 
  
 
~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       ALT-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 will save you the trouble of hunting for a printed ASCII 
table. 
Note that MODIFY allows you to type ASCII characters directly 
into emulation memory and target RAM. 
 
~ASCII`ASCII <character>  
Converts the next character into the ASCII code for that 
character.  See also EMIT.  
  
{{USAGE}  
As a quick way to get ASCII code for a single character.  See 
also ASC, the on-line ascii table. 
  
{{EXAMPLE  
  
ASCII z}  
Will leave on the stack the ASCII code  
for lower case z.  
 
~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.    
Press ESC to exit from the assembler. 
  
{{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 in.  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.  
  
Create a new file with OPEN <file name>.  It will be created with  
3 screens.  Increase the 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 from another file, use F10 
twice, once to get into the Menu system, then once to exit.  This 
re-opens the UniLab system file.  If you don't do this,  then 
some of the on-line help facilities and error messages may 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       8420 Only 
  
Tells the host computer to look for the UniLab on serial port 1.  
This is the normal default condition.  Equivalent to setting up 
port address 2F8.  See also SPORT (Serial PORT). 
  
 
~AUX2`no parameters       8420 Only 
  
Tells the host computer to look for the UniLab on serial port 2.  
Equivalent to setting up port address 3F8.  Only use this command 
if you have the UniLab connected to serial port 2.  See also 
SPORT (Serial PORT). 
 
~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 101010001001.    
~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.  Or use FILES dialog box. 
   
{{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 only executable code.  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, LOADER for other formats. 
  
The Orion software can load to target RAM as well.  See STEP-INTO 
and RB.  
{{FOR ADVANCED USERS}
If you are using BINLOAD in advanced macros, you have two options:
     1. compile the name of the file name you wish to load in 
          the macro, or
     2. ask for file name when macro is executed.
To do type 1, compile as   : MY_LOAD 0 7FF BINLOAD MY.BIN ;
To do type 2, compile as   : MY_LOAD 0 7FF [COMPILE] BINLOAD ;
See also FILES. 
 
~BINSAVE`<1st addr> <2nd addr> BINSAVE <file name>  
  
Saves the specified section of memory as a file, prompts for  the 
file name if you do not include it.    
Or use the FILES dialog box instead. 
  
  
{{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 STEP-INTO and RB.  
  
See also FILES. 
  
{{FOR ADVANCED USERS}
If you are using BINSAVE in advanced macros, you have two options:
     1. compile the name of the file name you wish to save in 
          the macro, or
     2. ask for file name when macro is executed.
To do type 1, compile as   : MY_LOAD 0 7FF BINSAVE MY.BIN ;
To do type 2, compile as   : MY_LOAD 0 7FF [COMPILE] BINSAVE ;
~BPDM`no parameters         F8 
  
Turns on disassemble at breakpoint feature. This shows an 
additional two lines disassembled from the current breakpoint.
If the next instruction will jump or branch, then the
display will show "Will Go To" and disassemble from the
address to be executed after the jump or branch.
  
{{USAGE}  
Usually accessed by the MODE panel (F8). In the command mode
you can disable this with BPDM'
  
Use this if you want to see two extra lines disassembled at
the breakpoint display, and to see if a conditional branch
will be taken.
  
~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, and EDIT_MACROS for info on simple 
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.   
~BPT`no parameters         F8 
  
Turns on trace to breakpoint feature. This is not available on 
every DDB package, but even if it is absent, you can usually
inspect the trace buffer after the first breakpoint to see events
leading up to the break.  Use the Home key or <cy> TN to see
the data in the trace buffer. You will see the breakpoint
SWI opcode being executed or a hardware interrupt occurring,
then the code will go to the reserved area to do the DEBUG
breakpoint.
  
{{USAGE}  
Usually accessed by the MODE panel (F8). In command mode you
can use BPT' to turn it back off.
  
Use this if you want to see a trace leading up to the first 
breakpoint.    
  
~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 menu directory of all the available pinouts-- the 
proper cable hook-ups for each microprocessor.  
{{USAGE}  
Once this word is entered, select the number of the 
microprocessor diagram you'd like displayed on the screen.  You 
can continue looking at other pinouts until you press the ESC key 
to exit the CATALOG menu. 
The pinouts are in three "library" files on the Utilities 
diskette.  The UniLab system can run without these files, but 
CATALOG and PINOUT will not work unless these files are in the 
\ORION directory on your disk.   
 
~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.  
  
SYMLOAD clears out the symbol table before it loads in the new 
symbols. 
  
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.  
 
~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.     
 
~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 CONT 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 A0 CONT tells the UniLab to only look at the  
upper 4 bits of the CONT lines.  The A0 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`CONTROL FILTER       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 filter 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.   
FKEY? (ALT-F1) shows 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 
EDIT_MACROS for information on easy macros. 
  
See also FKEY, and ALT-FKEY. 
  
 
~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.    
See also USEC?, to count the number of milliseconds between two 
addresses.  
{{BUS CYCLE COUNT}  
Not the number of machine cycles, nor the number of instructions  
fetched, but rather the number of bus cycles that occur between 
when the first address and the second show up on the bus. 
  
{{EXAMPLES  
  
  
123 123 CYCLES?}  
counts cycles between two occurrences of the address 123.     
{123 456 CYCLES? }  
counts cycles between address 123 and address 456.   
  
  
{{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?.     
~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 and SAMP.  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.  
  
  
{{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 so that the trigger event is 
near the top of the trace buffer (ten cycles from the top).   
{{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 set DCYCLES so that the trigger is, 
respectively, at the top, middle or bottom of the trace. S+ 
increases the number of delay cycles by 4 less than the size of 
the trace buffer (AAAH cycles on the 8620, AAH on the 8420) so  
you can see what happens after the end of the current trace.    
The maximum possible delay count is FFFF.    
             
 
~DEBUG`Press ALT-F1 to get on-line DEBUG help. 
ALT-F1 provides information on processor-specific features as 
well. 
For additional information, you can use HELP <command> on some of 
the following DEBUG commands: 
G              GB             GW              
LP             R              RB              
RZ             STEP-INTO      STEP-OVER 
 
~DEVENTS`<number of events> DEVENTS       RARELY USED  
  
Sets the number of trigger events that must occur before the  
UniLab freezes the trace.  Forces 1 DCYCLES.  
  
{{USAGE}  
To see the nth occurrence of an event.  Rarely a useful   
thing.  The nth occurrence shows up as the last cycle in   the 
trace buffer.  
  
See also PEVENTS.  
  
  
{{EXAMPLE  
  
NORMT 1800 TO 18FF ADR 30 DEVENTS }  
sets 30 devents-- last thing in trace will be   
the 30th access to memory between 1800 and 18FF.  
  
 
~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.  
Starting with versions 4.04 and 3.54, the PAGINATE switch on the 
Mode panel also sets DM to paginate if more than one screen full 
of code is disassembled.  Normally you would turn the PAGINATE  
switch off if you want to disassemble many lines to a printer  
or file.  Also see DN.   
  
 
~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`no parameters      
  
Places you into the special disassembly window on the right hand 
side of window.  Prompts you for starting address of disassembly.  
Displays one instruction per line and fills the disassembly 
window. 
  
{{USAGE}  
When you want to keep the disassembly from memory on the screen  
while performing 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 will stay on the screen if you 
exit from the DN display with END.  If you use ESC to exit, the 
disassembly will not stay on the screen.  
You can also get rid of the display by using F2 to get rid of the 
split screen and then scrolling the screen (or, if currently 
looking at an un-split screen, press F2 twice).  
  
  
{{EXAMPLES  
  
DN}  
This command never used in combination with anything else.    
~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 have any reason to use any 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.    
{{FOR ADVANCED USERS}
You cannot use DOS in advanced macros. In order to access DOS
functions in a macro, you use the lower level command <DOS>.
<DOS> expects the DOS command to precede it in quotes.
For example, if you wanted to change the name of a file with
a macro, you would do it like this:
: CHANGE_FILE  " RENAME ORION.BIN  PLAN9.BIN" <DOS> ;
Or if you wanted a listing of all binary files in a directory 
called \WORK, you would enter:
: WORK_DIR  " DIR \WORK\*.BIN" <DOS> ;
Note that the first quote must have a leading and trailing space.
~EDIT_MACROS`no parameters       SHIFT-F10         
  
Enters the macro display/edit panel.   
  
{{USAGE}  
EDIT_MACROS provides an easy interface for assigning a series of 
commands to a function key.  
Once within the EDIT_MACROS panel, choose a macro number, and 
then type any series of commands that will execute from the 
keyboard.  This group of commands is assigned to a SHIFTed 
function key. 
For example, if you type 3 when prompted for the macro number, 
your macro will be assigned to function key SHIFT-F3, as well as 
to the command MACRO_3.  
{{EXAMPLE  
  
EDIT_MACROS}  
After you type EDIT_MACROS, you will be prompted  
for the number of the macro that you wish to 
define or edit. 
 
~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.  
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.  
{{SIDE EFFECT}  
This word also disables the DEBUG features.   To turn them on  
again for use with emulation ROM, use the DEBUG enable/disable 
toggle of the mode panel (F8) or RSP.   
  
  
{{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.  See also SET-EM. 
  
{{USAGE}  
Use this word to enable memory within a macro.  Otherwise, use 
the  easier interface of SET-EM. 
Note that you must first set =EMSEG properly when you use 
EMENABLE. 
 
With a single address EMENABLE enables the 2K memory region that 
includes the given address.   With a range, EMENABLE enables the 
group of 2K blocks that contain the range. 
  
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.   
 
~EMIT`<ascii code> EMIT   
Types the character that corresponds to the ASCII code.  
See also ASCII.  
  
{{USAGE}  
As a quick way to get the character that corresponds to an ASCII 
code.  
See also ASC, the on-line ascii table. 
{{EXAMPLE  
  
03 EMIT}  
Will type out a heart-shaped graphic character. 
 
~EMMOVE0`<start addr> <end addr> <dest> EMMOVE0       8620 Only   
Moves a block of memory from current page of emulation memory to 
PAGE0. 
{{USAGE}  
Move data from one 64K page of emulation memory to the other.  
See also MMOVE, for moves within a page, and EMMOVE1, for moving 
to PAGE1. 
  
{{EXAMPLES  
  
PAGE1 1000 2000 1000 EMMOVE0 }  
After making PAGE1 the current page, copies  
the data at 1000-2000 to address 1000 in PAGE0. 
  
  
{PAGE1 200 2FF FF00 EMMOVE0}  
copies the data at 200-2FF in PAGE1  
to FF00-FFFF in PAGE0.  
  
  
{{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.  
 
~EMMOVE1`<start addr> <end addr> <dest> EMMOVE1       8620 Only   
Moves a block of memory from current page of emulation memory to 
PAGE1. 
{{USAGE}  
Move data from one 64K page of emulation memory to the other.  
See also MMOVE, for moves within a page. 
See EMMOVE0 for more information.  
 
~EMSTAT`no parameters        
  
Shows a graphical display of emulation memory status, as well as  
a text description.   See also SET-EM. 
{{USAGE}  
To see which 2K blocks of memory are emulated by the UniLab.     
{{EXAMPLES  
  
EMSTAT}  
This command never used in combination with anything else.     
~ESTAT`no parameters  
  
Gives text description only of status of emulation memory.    See 
EMSTAT, SET-EM. 
 
~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.    
  
  
{{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, included with most processor-specific package, 
specifies a range of CONT values corresponding to fetch cycles.   
~FILES`no parameters       F5        
Access to all file load/save/compare functions.  
{{USAGE}  
Whenever you need to save or load information, use FILES to call 
up the master list of file dialog boxes.   
Choose the file utility you want by moving the highlight bar  
with the cursor keys, and then press ENTER or END. 
  
{{EXAMPLE  
  
FILES}  
This command never used in combination with 
anything else.  
{{COMMENTS}  
Within a macro, you will usually want to use the file load  and 
save primitives (such as BINLOAD, BINSAVE, etc.) rather than 
calling the dialog box. 
 
~FILTER`<filter type> FILTER       RARELY USED  
  
Selects trace filtering type, 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 MISC'  
filtering.  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.  
 
~FIND-ADR`<16-bit value> FIND-ADR       See FIND-XXXX   
 
~FIND-CONT`<8-bit value> FIND-CONT       See FIND-XXXX   
 
~FIND-DATA`<8-bit value> FIND-DATA       See FIND-XXXX   
 
~FIND-HADR`<8-bit value> FIND-HADR       See FIND-XXXX   
 
~FIND-HDATA`<8-bit value> FIND-HDATA      See FIND-XXXX   
 
~FIND-LADR`<8-bit value> FIND-LADR       See FIND-XXXX   
 
~FIND-MISC`<8-bit value> FIND-MISC       See FIND-XXXX   
 
~FIND-WDATA`<16-bit value> FIND-WDATA     See FIND-XXXX   
 
~FIND-XXXX`<value> FIND-XXXX       8620 Only         
  
The "FIND-" family of words will search the trace buffer for a 
particular value. 
   
{{USAGE}  
Use to search the trace buffer from the start for an address,  
data, MISC or CONT value.  NX will find the next match. 
The FIND-XXXX family of words: 
        FIND-ADR      FIND-LADR      FIND-HADR 
        FIND-WDATA    FIND-DATA      FIND-HDATA 
        FIND-MISC     FIND-CONT 
The FIND- words search for 8-bit values, except for  
FIND-ADR and FIND-WDATA, which search for 16-bit values. 
{{EXAMPLE  
  
3289 FIND-ADR}  
Finds the address 3289 in the current trace buffer.  
  
 
~FKEY`<# of key> FKEY  <command>  
  
Assigns a command to a function key.   
See also ALT-FKEY, CTRL-FKEY, and EDIT_MACROS. 
  
{{USAGE}  
Reassign the function keys on PCs and PC look-alikes.  Use FKEY?  
(ALT-F1) to see 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.  
  
  
 
~FKEY?`no parameters       ALT-F3  
  
Displays all the current function key assignments.  
  
{{USAGE}  
To see what pressing any function keys will do for you. You can 
execute any of the assigned functions immediately,  
or you can press the SPACE bar to exit the display. 
  
See FKEY, ALT-FKEY, CTRL-FKEY and EDIT_MACROS to reassign keys.   
  
{{EXAMPLES  
  
FKEY? }  
This command never used in combination with anything else.     
 
~G`<address> G  
  
Goes to the indicated address, then lets the program continue. 
This is the same as changing the microprocessor's program 
counter. 
  
{{USAGE}  
After you have set a breakpoint, and want to release the  
microprocessor from the DEBUG breakpoint and let it resume 
execution of its program, G is one of several ways to do  
this.  
A better way is GW, which will not release the processor from 
breakpoint until you start the analyzer. 
  
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 breakpoint and resumes the target program at  location 
1030.  
  
  
{{COMMENTS}  
Appropriate if you have a DEBUG package and have run to a 
breakpoint by entering RESET adr RB, or STEP-INTO.   
You can return to any point in the program you like, and the 
target will be released from the breakpoint and immediately run 
in real time.  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 alter the program counter and then stop at a 
DEBUG breakpoint.   
The two addresses can be same. 
  
  
{{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 are at a breakpoint.  
See RB to Run to Breakpoint. 
  
 
~GW`<address> GW  
  
Goes to the indicated address and waits until the analyzer is  
started.  Releases the target board from breakpoint.  
  
{{USAGE}  
When at a DEBUG breakpoint, a way to capture a trace of the 
continuation of the program.    
The processor will execute starting at the given address when the 
analyzer is started with S.  Even if you are not defining a new 
trigger spec, use one of the NORMx words to clear out the DEBUG 
trigger spec before starting the analyzer. 
  
  
{{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.  
This command utilizes the combination of breakpoints and the 
UniLab analyzer.  Make sure that one of the NORMx words are used 
to clear out any trigger spec that DEBUG may have set. 
Note that reset is always turned off after any DEBUG operation. 
 
~H>D`Replaced by T.  
  
Displays the decimal equivalent of a hex number.  
  
 
~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 byte, HADR the higher.  
 
~HARDWARE`no parameters       F8  
  
Enables the hardware single-step features:  immediate breakpoint, 
hardware step-into, and changing/inspecting target RAM or I/O 
when not at a breakpoint (auto-breakpoint).   
   
{{USAGE}  
The STEP-INTO command follows jumps and branches in the target 
program.  It works either through the use of a hardware interrupt 
on the processor, or through a software simulation. 
You can toggle STEP-INTO between software and hardware 
functionality.  Enable the hardware STEP-INTO with HARDWARE.  
Enable the software STEP-INTO with SOFTWARE.  Normally you will 
use the MODE panel (function key 8) to toggle this feature.   
{{SOFTWARE STEP-INTO}  
The software STEP-INTO will follow all program branches and 
returns, but cannot follow interrupts or give immediate 
breakpoints. 
{{HARDWARE STEP-INTO} 
Hardware STEP-INTO makes use of a hardware interrupt of the 
target processor.  The UniLab uses either the non-maskable 
interrupt (nmi) or an interrupt request (irq) to get an immediate 
DEBUG breakpoint. 
{{WHEN TO TOGGLE} 
Toggle to SOFTWARE when you don't want the UniLab to make use of 
the target system's hardware interrupt.  See RSP' to disable the 
use of all target resources. 
On some processors, hardware STEP-INTO will "double-step" through 
short opcodes, while software STEP-INTO will always step through 
a single instruction.  With these processors (for example, the 
8096 family) you might want to toggle between HARDWARE to achieve 
immediate breakpoints, and SOFTWARE to single-step. 
On any processor, toggle to HARDWARE when you want to have 
immediate breakpoints and auto-breakpoints.  Auto-breakpoints 
occur when you try to access target RAM or a port while the 
target program is running (target not at a breakpoint). 
 
  
~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 HDATA and 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 set DEVENTS to capture the number of events you want 
to see (up to the size of the trace buffer). 
 
~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 the least significant 
data bit 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.    
{{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 on the 16-bit data value 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.  
 
~HELP`HELP <command>      F1  
  
Finds the reference information for a command or feature.  With  
no word following, brings up a screen of information about on- 
line help resources.  Press CTRL-F1 for additional help by 
category, ALT-F1 for help with processor-specific functions.  
SHIFT-F1 displays the current "easy macros." 
  
{{USAGE}  
Look up information on a command in the abridged on-line command  
reference, or get a "road map" of the help facilities.  
See also WORDS.  
  
{{EXAMPLES  
  
HELP}  
displays help screen.  
  
{HELP BYE}  
gives information on command "bye."  
 
~HELP_DEBUG`no parameters      ALT-F1  
On-line help for DEBUG operations and processor-specific 
features.  
~HELP_MORE`no parameters      CTRL-F1  
  
Help by category on a variety of UniLab functionalities. 
 
~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.  
Or, you can use the FILES dialog box instead. 
  
{{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, or with FILES.   
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 are at a 
breakpoint when you start the HEXLOAD.  To do that you must have 
a program already loaded into emulation memory (LTARG for 
example) and then run to a breakpoint with RESET <address> RB. 
  
If the processor is not at a breakpoint, you will see the message 
"Not emulation memory."  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 emulation memory" message for each invalid address.  
Enabled addresses in the file will be properly loaded.  
See also FILES. 
{{FOR ADVANCED USERS}
If you are using HEXLOAD in advanced macros, you have two options:
     1. compile the name of the file name you wish to load in 
          the macro, or
     2. ask for file name when macro is executed.
To do type 1, compile as   : MY_LOAD HEXLOAD  MY.HEX  STARTUP  ;
To do type 2, compile as   : MY_LOAD [COMPILE] HEXLOAD  STARTUP ;
~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.   
Or, use the FILES dialog box for both saving and loading. 
  
{{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.  Or, use the FILES dialog box.   
{{USAGE}  
Save as 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 AHIST, THIST or MHIST. 
  
 
~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.    
  
 
~INIT`no parameters   
  
Sends an initialization message to the UniLab.  
  
{{USAGE}  
To re-initialize the UniLab after you are in the UniLab program.  
When you start up the program, it initializes 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 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.  
  
{{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. 

~INSIGHT`no parameters       CTRL-F3       8620 Only
Easy access to the Insight display/control panel.
{{USAGE} 
Places you in the Insight panel, setup to poll the processor at
any address.  See also RESIGHT, to re-enter Insight with the
previously set Insight trigger specification intact.
{{EXAMPLE 
INSIGHT} 
This command is never used in combination with anything else.    
~INT`no parameters       RARELY USED 
Generates a low-going signal on the NMI- wire when qualifiers
have been satisfied.   Signal goes high again when trigger is
satisfied.
{{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 STEP-INTO feature of the
Orion
software with the Mode Panel (F8) or with NMIVEC'. 
NORMx turns off INT.
{{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. See INT.
{{USAGE} 
Not often used since NORMx also disables the INT mode.  Only used
if you wish to reissue the current trigger specification without
generating a hardware interrupt signal.

~IS`<value>  IS  <name> 
Assigns a symbolic name to an address or data value. 
{{USAGE} 
To make mnemonic names of memory locations, which can be used 
with commands, and will show up in traces and disassembly
displays.  If  you already have an assembler generated symbol
table, you will  prefer to use the symbol table features of the
UniLab.  See  LOADER.
IS turns on symbol display mode. 
{{EXAMPLE 
1234 IS MREGISTER } 
gives 1234 the symbol name "MREGISTER"   
{{COMMENTS} 
See also FILES, ISMODULE, ISOFFSET, ISSEG, SYMB, SYMB', SYMSAVE,
CLRSYM, SYMLOAD.

~ISMODULE`<file # in symbol table> ISMODULE <new-name> 
Assigns a new name to a file number.
{{USAGE} 
To change the name of the file referenced by line number symbols 
in the symbol table.  
Use this command when the symbol table has assigned an inaccurate 
file extension to a file name.  
{{EXAMPLE 
1 ISMODULE OUT.C  } 
assigns the name OUT.C to module #1 in the 
UniLab's symbol table. 
{3 ISMODULE PROM0000 } 
assigns the name PROM0000 to module #3.
{{COMMENTS} 
See also FILES, IS, ISSEG, SYMB, SYMB', SYMSAVE, CLRSYM, and
SYMLOAD.


~ISOFFSET`<16-bit offset> ISOFFSET <name> 
Assigns a symbolic name to an offset from the current segment. 
For use with 8088/86 family DDB only. 
{{USAGE} 
To make mnemonic names of memory locations, which can be used 
with commands, and will show up in traces and disassembly
displays.  If   you already have an assembler generated symbol
table, you will  prefer to use the symbol table features of the
UniLab.  See  LOADER.
ISOFFSET creates a "segmented symbol" whose value depends on both 
the offset and the current segment.  ISOFFSET defaults to using 
the value of CS:, but you can override this default.  See the 
example below. 
ISOFFSET will create an unnamed segment symbol if a segment 
symbol with the correct value does not yet exist. 
ISOFFSET also turns on symbol display mode. 
For more information on ISOFFSET and the 8088/86 address space, 
refer to Engineering Technical Note #24 (ETN-24). 
{{EXAMPLE 
1234 ISOFFSET CODE-ADR  } 
gives the name CODE-ADR to 1234 offset from CS:  
{9988: 5678 ISOFFSET MYSYMB } 
assigns the name MYSYMB to 5678 offset from 9988. 
{{COMMENTS} 
See also IS, ISMODULE, ISSEG, SYMB, SYMB', SYMSAVE, CLRSYM,
SYMLOAD. 

~ISSEG`<value> ISSEG <name> 
Assigns a symbolic name to a segment value.  For use with 8088/86 
family DDB only. 
{{USAGE} 
To assign a mnemonic name to a segment, for use in operations on 
memory with the UniLab. If you already have an assembler 
generated symbol table, you will prefer to use the symbol table 
features of the UniLab.  See LOADER. 
You can use the ISSEG command to add symbols before or after you 
have loaded in a symbol table. 
Create a named offset symbol before using ISOFFSET, since 
ISOFFSET will create an unnamed segment symbol when a segment 
symbol with the correct value does not yet exist. 
When you enter the name of a segment symbol, it updates the value 
of the segment that will override the default on the next memory 
operation. For more information on ISSEG and the 8088/86 address 
space, refer to Engineering Technical Note #24 (ETN-24). 
{{EXAMPLE 
9988 ISSEG MYSEG } 
gives the name MYSEG to segment value 9988 
{{COMMENTS} 
See also IS, ISMODULE, ISOFFSET, SYMB, SYMB', SYMSAVE, CLRSYM, 
SYMLOAD.

~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. 

~LOADER`not a system command--call from DOS 
Load object code files, or mixed symbol/object files.   
{{USAGE} 
The LOADER is a standalone application for processing OMF and
other files. 
{{Invoking the loader}
The program is named LOADER.EXE.  The suggested usage is calling
it in a batch file after your linker, and before invoking the
UniLab.  Call it with command line arguments (see below).
You can also invoke it from DOS with the command LOADER. 
{{Formats processed by LOADER}
This release will load in seven types of files, as shown by the
menu, and also provides the ability to define your own format:
F1 OMF51  -- Intel Object Module Format for the 8051 family.(l o s)
F2 OMF86  -- Intel OMF for the 88/86 family.(l o s)
F3 TEKHEX -- Tektronix Hex. (o)
F4 MOTORS -- Motorola S records. (o)
F5 SYMFIX -- user defined fix length format. (s)    
F6 2500AD -- Linker option M (Microtek). (s)
F7 MANX   -- ASCII file: value, then name. (s)
F8 AVOCET -- ASCII file: name, then value. (s)
F9 SDSI   -- Software Develpment Systems, Inc. format (l o)
End EXIT from LOADER
Esc Go to LOADER command mode.
       s = symbols    o = object code     l = line numbers
The loader usually makes two passes through the file, and keeps
you informed of the loading status.   
{{Process a file from the menu}
Type the number corresponding to the format you want, and press
the ENTER key -- you will be prompted for the file name.  After
the file has been processed, the LOADER program terminates,
returning you to DOS.
{{Invoke the LOADER with command line arguments}
The loader takes the following command line arguments:
  -D                            eliminates duplicate symbols   
  -E                            report all errors and warnings 
  -O <filename>                 changes output filename
  -U                            disable upper case conversion 
  -W                            wait for user to press a key
                                 before exiting LOADER 
  <load command> <filename>     load (process) a file
       The load commands are:
       OMF51     OMF86     TEKHEX    MOTORS
       SYMFIX    2500AD    MANX      AVOCET    SDSI
and the load command must be the last command line argument.
For example:
       C> LOADER -O VERS02   -D   OMF51 SIEVE.A51
will process file SIEVE.A51, eliminate duplicate symbols, and
create output files VERS02.BIN and VERS02.SYM.  
The -W switch is mainly for use when the LOADER is called from 
within a larger batch file.  If you need to see the size of
the files produced, it will be on the screen then erased if there
is another command after the LOADER is executed.  The -W switch
causes the LOADER to wait for you to press a key before it
exits.
The -U switch will allow you to load symbols that are case 
sensitive.  When you use these in the UniLab, you might want 
to go to MACRO mode and enter 
     ' L/U? OFF
to make the UniLab case sensitive.  Once this is done, all 
commands must be entered in upper case. If you use -U on
a command line invoking the loader, make sure that all
commands are uppercase.
When you invoke the loader with command line arguments, it will
exit to DOS upon successful completion of the load.
Note that SYMFIX requires six parameters, as described in the 
help entry for SYMFIX.
{{Process a file with commands from within LOADER} 
You can use any of the command line arguments after you are in
the loader.  First, type 9 to get into command mode, then enter
the command.  Command mode allows you to look back over a record
of the loading process (see below).  Use the command BYE to exit.
{{Review the loading -- command mode only}
If you wish to review the loading process, press F5 repeatedly. 
This moves backward through a recorded buffer of the actions
taken by the loader.  Move forward again with F6.  
{{Files created by loader}
The loaders create binary files containing the object code, and,
if the file contains symbols, a symbol file.  
The symbols are saved to the file <base-name>.SYM, where 
<base-name> is ORION unless you use the -o command.
If the format can only address a single 64K segment ( OMF51,
TEKHEX), then the object code is saved in a file called <base-
name>.BIN.  
If the format can address multiple 64K segments, then a binary
file is created for each 64K emulation memory segment that is
addressed by the file.  Each of these files has a name in the
form X<base-name>.BIN, where X is the hexadecimal number of the
=EMSEG to load the file into.  For example, FORION.BIN should get
loaded into F =EMSEG.
{{Load into UniLab}
After loader creates these files, it tells you where to load each
binary file.  
From within the UniLab program, enable memory in the proper
emseg, and use BINLOAD to load the binary file(s).  
The symbol file is in Orion format, and gets loaded in with
SYMLOAD.
The binary file (but not the symbol file) can be loaded into the
UDL as well.
This release of the LOADER supports eight formats and has,
with SYMFIX, the ability to load other fixed format symbol
records: 
   absolute Object Module Format (OMF) for the 8051 family, 
    OMF for the 8086 family, 
   Tektronix Hex (but not yet extended TekHex), 
   Motorola S records,
   2500AD symbol files (linker option M-- Microtek),
   MANX symbol files (and any other file with one symbol per line, 
    four hex-digit value followed by name),
   AVOCET symbol files (and any other file with one symbol per line, 
    name followed by four hex-digit value).
   Software Development Systems, Inc. cross-compiler and cross-
    assembler output files.
When you enter the LOADER, you are presented with a menu of  
supported formats. 
The LOADER produces symbol and binary files, which must then be 
loaded into the UniLab system with SYMLOAD and BINLOAD or with
FILES. 
{{Known support for symbol tables of assemblers and compilers}
{2500AD}
Specify file format M to the linker, and will output a "Microtek"
format file.
{8051 family compilers}
Most of these will output an OMF-51 file.  Look for the OMF-51
option, or the "Intel compatible."
{8088 and 8086 family compilers}
Most of these will output an OMF-86 file.  Look for the OMF-86
option, or the "Intel compatible."
{Archimedes-- 8051}
specify file format -F AOMF8051 to the linker, and will output
OMF-51 file.
{Archimedes-- Other processors}
specify -F MSD-I and will output "Manx" file (ASCII file, value
followed by name).
{Avocet}
Specify option -PlainDump and linker will output "Avocet" file
(ASCII file, name followed by value).
{Allen-Ashley}
Produces "Avocet" file (ASCII file, name followed by value).
{Manx}
Specify option -T to linker. Output will be "Manx" symbol file.
{Software Development Systems, Inc.}
Use the -f option from the compiler, and set the downloader to
the "image" format for binary object files. Use the -w option 
with the downloader to prevent trying to load into RAM.

~LP`no parameters 
Goes around a loop once and stops. 
{{USAGE} 
You must already be at a DEBUG breakpoint (see RB) 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
STEP-OVER (a single step without following branches) and then
executing <savedaddress> RB.  Processors with multiple byte
breakpoint opcodes may execute STEP-OVER 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.  As with all memory altering commands, can change
RAM at a breakpoint.
{{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 STEP-INTO and RB.    

~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 at a breakpoint. See RB. 
{{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 STEP-INTO 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 STEP-INTO 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 the Reference Manual Appendix "Writing Macros".   See also
EDIT_MACROS, for information on simple macros.
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.      
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.  

~MACRO_2`no parameters    SHIFT-F2    See EDIT_MACROS. 

~MACRO_3`no parameters    SHIFT-F3    See EDIT_MACROS. 

~MACRO_4`no parameters    SHIFT-F4    See EDIT_MACROS. 

~MACRO_5`no parameters    SHIFT-F5    See EDIT_MACROS. 

~MACRO_6`no parameters    SHIFT-F6    See EDIT_MACROS. 

~MACRO_7`no parameters    SHIFT-F7    See EDIT_MACROS. 

~MACRO_8`no parameters    SHIFT-F8    See EDIT_MACROS. 

~MACRO_9`no parameters    SHIFT-F9    See EDIT_MACROS. 

~MAKE-OPERATOR`   MAKE-OPERATOR <file-name>       Macro Sys   
Use this command to create an operator system that has restricted
access to the UniLab commands, but also has access to words  that
you have defined.  
{{USAGE} 
This command performs four actions: 
     1) save the macro system,
     2) create a new version of the operator system,  
     3) save the new operator system, and
     4) exit to DOS. 
The new, non-standard operator system recognizes any 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
Utilities diskette.   
{{EXAMPLE 
OPERATOR TESTER} 
Saves a macro system with the name TESTER, 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 STEP-INTO and
RB.  
~MDUMP`<from addr> <to addr>  MDUMP 
Display the contents of an area of memory.  See also MODIFY.  
{{USAGE} 
Allows you to look at any size block of memory.
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 STEP-INTO and RB. 

~MEMO`no parameters       ALT-F2        
Displays and allows editing of the on-line memo pad. 
{{USAGE} 
A handy way to keep notes to yourself, and to store macros  or
useful series of commands.
Help prompts are always displayed.  Press F1 for more help.   
You exit the full screen editor with ESCAPE or END.  
END will save your work, ESC will allow you to exit without 
saving your changes to the screen.
{{EXAMPLE 
MEMO } 
This command never used in combination with anything else.       
          
{{COMMENTS} 
This command works only when the EDITxx.VIR and MEMO.SCR files
from the Utilities diskette are present in the same directory as
the UniLab program.

~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 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 HSAVE
<file>, or with the FILES panel.  Issue this command after you
exit from the histogram. 
You load the histogram back in with HLOAD <file> (or with FILES).
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 <i> MASK <j> 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 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, 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 FILTERING} 
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 (M0 to M7) and HDATA inputs (D8 to D15).
NORMx turns filtering 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 inputs except M0-M7, D8-D15.

~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 reference address), 
to patch program memory.  Can be used to change RAM when the
processor is at a breakpoint. See RB. 
{{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!.  See ASM for information on the line-by-line
assembler.
Will store to emulated memory if the address is enabled, 
otherwise will store to target RAM.   See STEP-INTO 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, when the processor is
at a breakpoint. See RB. 
{{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 STEP-INTO 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 
Puts you into the mode panels, which allow you to change mode of 
display, to toggle features on and off, 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 toggle
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. 
Press F1 to get help for the current feature.
{{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  COLOR
{{Panel Three    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` See STEP-OVER    F3

~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` See STEP-INTO      F4 

~NMIVEC`no parameters       F8 
Enables the hardware STEP-INTO (Non-Maskable Interrupt vector
installation).  See HARDWARE.
~NMIVEC'`no parameters       F8 
Disables the hardware STEP-INTO function (Non-Maskable Interrupt
vector installation).  Enables software STEP-INTO.  See SOFTWARE.
  
~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 and HDATA inputs. 
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 see 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,
after adding to the delay count -- 2726 decimal with the 8620,
166 decimal with 8420 -- 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 1365 decimal on the 8620, 
55 on the 8420. 

~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 2720 decimal on the 8620,
160 on the 8420.

~NOT`NOT  <trigger description> 
The following 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 trace
buffer full of 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. 
                    

~NX`no parameters       8620 Only
Finds the next match of the current FIND-xxxx value.
{{USAGE} 
To search the current trace buffer for a value.  
For example, you want to search the trace buffer for all
access to a particular memory location.
{{EXAMPLE
NX} 
This command never used in combination with 
anything else. 

~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 cycles with 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 the ESC key.  Then enter
T 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 the
hardware STEP-INTO enabled, you can alter RAM at any time, since
the UniLab will automatically force the processor to vector to a
DEBUG breakpoint, read the RAM and then release the processor to
resume execution of the target program. 
If you disable STEP-INTO (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!.   See ASM for information on the line-by-
line assembler.

~PAGE0`no parameters 
Only for UniLabs with 128K of memory.  Selects the bottom 64K 
page of emulation memory (even EMSEG value). 
{{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.     
For example, if your =EMSEG values are E and F, this command sets
the EMSEG to E (even =EMSEG),  while PAGE1 sets the EMSEG to F. 
Thus, address 1300 after PAGE0 refers to location E1300.  Address
1300 after PAGE1 means location F1300. 
{{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 (odd EMSEG value). 
{{USAGE} 
See PAGE0  above. 

If the emseg values are 0 and 1, 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. 
After using PATCH or after selecting the processor from the
initial log-on menu, you can use SAVE-SYS to save the system.The
selection menu will no longer be presented each time you enter
the system.  Use PATCH later only if you want to re-configure for
one of the other processors supported by your DDB software.
{{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      ALT-F10
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       8420 Only
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 now 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 analyzer must first find the
qualifying 
events before it starts looking 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. If you do want to specify a trigger
that occurs immediately after the qualifiers, use INFINITE
PEVENTS.   
{{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.  RESET must be enabled to establish the first
breakpoint.
{{USAGE} 
The first breakpoint must be in emulated ROM, and come after the 
stack pointer has been initialized.  
RB will enable RSP, and disable RESET.
You can also use STEP-INTO or RI and SI to establish a DEBUG
breakpoint.

{{MISSED BREAKPOINTS} 
If the breakpoint is not reached, then the program will continue 
to run until you press any key.  Pressing a key while waiting for
breakpoint causes the UniLab to try to STEP-INTO your program.  
If you fail to reach a breakpoint, you must then use RESET
<address> RB.  
You can set a breakpoint only on the address of the first byte of
an instruction.  To make certain that the address you try to set
a breakpoint on is executed by the program, set an analyzer
trigger on the same address with <address> AS.   
And make sure that your stack pointer points to working 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 are already at a
breakpoint.
RESET does not restart your target board-- it turns on the
"reset" flag.  The S, AS or RB command 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. 

~READ-ROM`no parameters        
Places you in the ROM read panel.
{{USAGE} 
Access to the ROM reading routines.  This command presents you
with a menu of supported ROMs.  
From this panel, read a ROM into emulation memory by pressing the
number that labels the ROM type.  The software will prompt  for
the addresses in emulation memory that the ROM is to be read
into.

~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 access command>      ALT-F5
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: run to a
breakpoint before you access emulation memory.  That way, your 
processor will be held at the DEBUG breakpoint 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.  

~RES-'`no parameters 
Disables protracted reset pulse. 
{{USAGE} 
The UniLab writes into the reserved area whenever the analyzer is
started with RESET enabled.   
To prevent unpredictable processor behavior, the UniLab pulls 
analyzer cable line res- low before writing into emulation 
memory.  The res- line is held low for a long time, while the 
analyzer is armed and started running.  
If the protracted length of the reset pulse causes problems, 
disable it with RES-'. 

~RESET`no parameters       F8 
Turns on the reset flag, so that the target system is restarted
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 watch a
program already in operation. 
To get a breakpoint the first time with RB you must enable reset.
Always type RESET <address> RB for the first breakpoint 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. 

~RESIGHT`no parameters       CTRL-F4       8620 Only
Re-enters the InSight control/display panel, preserving the
previously set InSight trigger address specification.
{{USAGE} 
Access to the new real-time InSight display.  
The command INSIGHT enters the same panel, but changes the
trigger address specification to ANY ADR (0000 TO FFFF ADR).
Whether you enter with RESIGHT or INSIGHT, you can change the
trigger specification from within the InSight display.
{{EXAMPLE
RESIGHT} 
Re-enter the InSight panel.

~RI`RI  <trigger spec> SI  
Allows you to get a DEBUG breakpoint when <trigger spec> is met. 
{{USAGE} 
To get a breakpoint 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 feature asserts a
hardware STEP-INTO signal.  Generally, it will take a couple of
instructions cycles for the processor to respond to the signal. 

{{EXAMPLES 
RI 450 TO 470 ADR SI} 
Will get a breakpoint after any address in the range 450 to  470
appears on the bus. 
{RI WRITE  34 DATA SI} 
Will get a breakpoint 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 running to a
breakpoint, which you do with STEP-INTO 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-F1 and then
type 2, 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 toggle this feature. 

~RZ`no parameters 
Resume program from breakpoint, without any breakpoints set.    
{{USAGE} 
When you want to run the program starting from the current 
address.  
A handy command for releasing the processor when from breakpoint.
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 AA6.
{{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.  
S+ changes the value of DCYCLES and then starts the analyzer
again. 
If your trigger spec is only met once in the course of program
execution and RESET is disabled, then the UniLab will be
searching a program in progress for an event that will not occur
again. 
{{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 
path-names changed.  Or, just to save the current emulator enable
values, or 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" .EXE.  
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 the Reference Manual Appendix
"Writing Macros". 
{{EXAMPLE 
400 SC test } 
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-EM`     no parameters        ALT-F7     
User friendly enabling of emulation memory.  
{{USAGE} 
Use the space bar to toggle emulation of any 2K memory block. Use
the cursor keys to move around.
CTRL-LeftArrow moves to EMSEG, and allows you to change the 64K
segment being emulated.  
Press END to save your new settings, 
      ESC to revert to the previous settings.
{{COMMENTS}
Eliminates need for =EMSEG, EMENABLE, and ESTAT, except within
macros.

~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. 

~SET-TRIG`     no parameters        F6     
Allows you to choose from list of useful pre-set triggers. 
{{USAGE} 
Use the cursor keys to move the highlight bar to the option you
want, then press END or ENTER to choose.  
The software will prompt you to enter any necessary values,  then
the analyzer will be started with the chosen trigger
specification.

~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. 

~SHOW_MACROS`no parameters     SHIFT-F1        
Displays the current assignments of the easy macros.  Change the
assignments with EDIT_MACROS (SHIFT-F10).
{{USAGE} 
The easy macros are assigned to function keys SHIFT-F2 through
SHIFT-F9.  These macros are user-definable while in the OPERATOR
mode.  
For on-line help with the easy macros, press F1 while in the
SHOW_MACROS screen.
{{EXAMPLE 
SHOW_MACROS} 
You would normally call up this function with the
function key SHIFT-F1.

~SI`RI  <trigger spec> SI  
Allows you to get a breakpoint when the <trigger spec> condition
is met.
{{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 a breakpoint 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 to run
to one of the breakpoints, either the address set by RB, GB or
any  of the addresses set by SMBP. If you are stopped at a
breakpoint  set by SMBP, you need to reset it with RMBP before
running to the  next breakpoint with RB or GB.
{{EXAMPLES 
123 4  SMBP} 
          sets a breakpoint #4 at address 123. 
4 RMBP  250 RB} 
Release the previous multiple breakpoint (assuming the breakpoint
occurred at address 0123) and run to a breakpoint at 250 or to
any  others that may have previously been set with SMBP.
  
{{COMMENTS} 
See also STEP-OVER, CLRMBP, RMBP. 
Before using multiple breakpoints, you should examine the 
possibility of using the powerful capabilities of the 
analyzer to do the same thing. 

~SOFT`SOFT <filename>          PPA 
Creates a new command file which has the optional Program
Performance Analyzer enabled.  Need be 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. 

~SOFTWARE`no parameters       F8 
Enables the software single-step features:  software step-into. 
Disables the hardware single-step features: immediate breakpoint
and auto-breakpoint. 
  
{{USAGE} 
The STEP-INTO command follows jumps and branches in the target
program.  It works either through the use of a hardware interrupt
on the processor, or through a software simulation.
You can toggle STEP-INTO between software and hardware
functionality.  Enable the hardware STEP-INTO with HARDWARE. 
Enable the software STEP-INTO with SOFTWARE.  Normally you will
use the MODE panel (function key 8) to toggle this feature.  
See HARDWARE for more details.
{{SOFTWARE STEP-INTO} 
The software STEP-INTO will follow all program branches and
returns, but cannot follow interrupts or give immediate
breakpoints.
~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 simultaneously look at two 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.    

~SPORT`<addr> SPORT !       8420 Only
Sets the address of the Serial PORT to which the UniLab is
connected. 
{{USAGE} 
Most PC compatible computers have one serial port at address 2F8.
The UniLab software defaults to this case.
If the serial port of your computer is at a non-standard address,
use this command to change the software.  SAVE-SYS to make the
change permanent. 
{{EXAMPLE 
3F8 SPORT !} 
Tells the software that the UniLab is connected
to serial port two, at address 3F8.  This has the 
same effect as using the command AUX2.

~SR`<n>  SR 
Starts 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 AA9 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} 
Use SST rather than S to start the analyzer looking for a bug you
think will take a while to find.  After this command, you can
disconnect the UniLab from the host, or 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 with TS as a "command tail", and if the trigger has been
reached,  the trace buffer will be displayed.  If it has not been
reached, initialize with the command INIT. 
If you re-enter the system without the TS command tail, press the
Enter key before the log-on screen is displayed.  This will
prevent the UniLab from trying to re-initialize and thus
overwrite any data it may have captured in the trace buffer.
{{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.   
See TS.

~SSTEP` See STEP-INTO, STEP-OVER. 

~STANDALONE`STANDALONE <prom programming command>       8420 Only
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 "Target processor stopped" message.  See
TroubleShooting  chapter. 

~STEP-INTO`no parameters       F4 
Either establishes a breakpoint immediately or, if you are
already at a breakpoint, 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 a breakpoint on a program that is 
currently running.  See also RB and RI.   
{{AUTO-BREAKPOINT} 
You can now read or write RAM and I/O when not at a breakpoint--
the UniLab will automatically do it for you.  When you try to
read RAM while a program is running, the UniLab will issue a
hardware STEP-INTO signal to achieve a breakpoint, perform the
requested function and then allow the program to resume.
{{SINGLE-STEPPING} 
When you are at a breakpoint, the STEP-INTO command allows you to
execute one instruction, no matter what that instruction is.  See
also STEP-OVER.   
The two STEP-xxxx commands allow for flexibility in following 
the execution of your code. STEP-INTO will follow jumps and
branches-- while STEP-OVER will fall through them. 
{{DISABLE} 
If your target board makes use of the non-maskable interrupt (or 
IRQ) feature of your processor, or you wish to disable STEP-INTO
for any other reason, use the third panel of the Mode Panel (F8)
or NMIVEC'.  
Disabling the DEBUG features (Mode panel choice "DEBUG" or 
command RSP') also disables NMI. 
On a number of DDBs, disabling the hardware STEP-INTO will enable
a software STEP-INTO.  The software STEP-INTO will follow all
program branches and returns.  To use it, toggle from hardware to
software on the STEP-INTO line in the MODE panel.  Then make
normal use STEP-INTO, or function key 4.
{{COMMENTS} 
The hardware interrupt feature is also utilized by SI.  Disabling
hardware STEP-INTO also disables that feature. 

~STEP-LINE`no parameters       Alt-F4 
Sets a breakpoint at the next higher address in memory tagged 
by a high-level language source line. 
{{USAGE} 
Now supported on all DEBUG software packages.  You must have 
high-level source lines in the UniLab symbol file.  Currently the 
UniLab LOADER utility can import these from an OMF86, OMF51,
and Software Development System output file.  You can also 
create your own with MAPSYM.
{{WATCH OUT} 
This command simply sets a breakpoint at the next line level and
then lets the program run.  If that address is never executed,
you will not get a breakpoint.  The best use of this feature is
to get to a point in your program tagged by a high-level source 
line, then use F3 and F4 to single-step into the code generated.
This is not intended to replace the simulation packages which
will allow you to step in sophisticated ways to debug C code.  
Rather it is a quick route to get to a point in your program 
where the UniLab analyzer or DEBUG functions can be used to 
inspect the low level routines. 
{{COMMENTS} 
This feature is essentially a "smart RB" and has the same action
as setting a breakpoint with RB at the next address tagged by a
high-level line symbol.
See also STEP-INTO and STEP-OVER.   

~STEP-OVER`no parameters    F3
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.  
Note that 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, STEP-OVER will show you the 
state of the processor when it returns from the call. 
Use STEP-INTO 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 
STEP-OVER when at 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 when the processor is at a breakpoint. 

~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. 

~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 SYMLOAD, both of which 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`        LOADER
Use LOADER to translate a symbol files made by cross assembler or
cross-compiler. 
{{USAGE} 
LOADER is capable of loading symbol tables in almost any format. 
See LOADER for more information.
Formats not on the LOADER 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. 

~SYMFIX`<a> <b> <c> <d> <e> <f>  SYMFIX     LOADER
Defines symbol file parameters for formats that use fixed length 
records.  This function is part of the standalone LOADER for
translating symbol files.
{{USAGE} 
Use this word to define your own symbol file format for fixed
length  records, if none of the predefined formats available in
the LOADER 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 = ASCII code of pad characters used to fill between symbols.
   f = record length. 
Notes:
Parameter a is "zero-indexed."  If the name field starts on the
third byte, use the value 2.
Parameter c is "one-indexed."  If the address field starts on the
third byte, use the value 3.
Parameter f is a count. If there are 5 bytes in the record, use
the value 5.
SYMFIX cannot skip over header information in files.  It is
designed for files that consist only of fixed length records.
{{EXAMPLE
C> LOADER 0 0 B 1 0 E SYMFIX MYFILE.SYM } 
defines the format for 2500AD abbreviated symbol table files. 
These files follow the format: 
no offset from start of record to start of name, (a=0)
ten bytes for the symbol name,
two bytes for the binary, MSB-first symbol value, (b=0, d=0) 
two pad bytes, for a total of 0Eh bytes. (f=0C)
The symbol value thus starts at offset 0Bh in the record. (c=0B)
The pad bytes are value 00. (e=00)
~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.  
If you have pagination turned on (F8), after a screen full of symbols 
is listed you will be prompted to press a key to continue.  
Continue by pressing any key, or exit by pressing Esc.  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.
Or, use the FILES dialog box.
{{USAGE} 
Loads up a symbol table that was saved with SYMSAVE or created by
the standalone LOADER. 
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. Or, use the FILES dialog box.
{{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.   
~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.   

~T.`<hex number> T. 
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 T. } 
will cause "16" to be displayed. 
{333 133 - T. } 
will display "512,"  which is the decimal equivalent of 333 minus
133 (hex). 

~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.  
You can use the FILES dialog box to perform the comparison.   
{{USAGE} 
Very useful for writing automatic system test programs.  Use the 
value AAA 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 5 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 
AAA 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.  Or, use the FILES dialog box.
{{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} 
Toggles 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, 
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 exit the UniLab
software with BYE and run other programs on your PC.  You can
even disconnect your host computer from the UniLab.  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 either override the automatic
UniLab init, or start the UniLab program with TS in the "command
tail."  To override the automatic init, invoke the UniLab
software and press the Enter key before the log-on display.  This
will prevent the UniLab from trying to initialize.  You can then
enter TS to upload the data and display it.  
{{EXAMPLE  
C> ULZ80 TS} 
The Z80 UniLab system is entered from DOS with the TS command
tail.If the system was previously exited after using an SST
trigger spec, then if the trigger has been reached, the trace
buffer data will be displayed upon re-entry.  If the red trigger
light on the UniLab is still on, the trigger has not been
reached.    
{{COMMENTS} 
Because of the 8420 serial interface,  the TS command on the 8420
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.  You can use the FILES
dialog box instead.
{{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.   You can also use the FILES
dialog box.
{{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.  

~USEC?`<from addr> <to addr>  USEC?       8620 Only 
Counts the number of micro-seconds (usec.) between two addresses.

{{USAGE} 
Can use to count the execution time of a loop, as in the 
first example below, or the execution time of any segment of
code, as in the second example.  
See also CYCLES?, to count the number of bus cycles between two
addresses. 
{{EXAMPLES 
123 123 USEC?} 
counts microseconds between two occurrences of the address 123.  
{123 456 USEC? } 
counts microseconds between address 123 and address 456.      
{{COMMENTS} 
Useful for checking execution times.
USEC? makes its own trigger spec, so you will have to start 
fresh on your trigger after using this command.

~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. 
~WRITE-EPROM`no parameters        
Places you in the EPROM programming panel.
{{USAGE} 
Access to the EPROM writing routines.  This command presents you
with a menu of supported ROMs.  
From this panel, program an EPROM by typing the number that
labels the type of EPROM.  The software will prompt for the 
addresses in emulation memory that are to be written to the 
EPROM. 

~WSIZE`no parameters       ALT-F8 
Allows you to redefine the size of the windows. 
{{USAGE} 
Once you enter this command, only the up and down arrow
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.   

