~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. 
~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. 
~:`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 Appendix F for further 
information.  See also BPEX. 
 
{{WHAT A MACRO IS} 
A macro is a command that you create out of previously defined 
commands. 
 
For example,  
 
{{: LOADUP     0 TO 3FFF BINLOAD A:MYPROG ;} 
 
creates a macro called LOADUP, which uses the previously defined 
UniLab command BINLOAD.  
LOADUP will always load from a file on drive A: called myprog.  
You can see how this would be easier than using BINLOAD every 
time you wanted to load this file.  
 
{{HOW TO WRITE MACROS} 
A macro definition begins with a colon and ends with a semicolon 
(;).  The first word after the : is the name of the macro, and 
all the other words are the definition of it. 
 
There must be at least one space between the colon and the name 
of the macro, and at least one space between the last word and 
the semicolon.    Like this: 
 
{{: NAME  FIRSTWORD SECONDWORD VALUE THIRDWORD ;} 
 
{{FORTH} 
When you define a macro, you are actually making use of the 
programming language FORTH.   With this powerful language you can 
define new words that make use of conditional statements, 
looping, and more.  The best introduction to the language is Leo 
Brodie's Starting FORTH.  
 
 
{{WHY MACROS} 
The example below defines a macro called READRAM.  After the new 
word has been defined, you would just type in READRAM every time 
you want to set up the trigger specification that shows only the 
cycles that read from the address range 1000 to 1FFF.  This will 
save you a lot of keystrokes. 
 
 
{{EXAMPLE 
 
:  READRAM  ONLY READ 1OOO TO 1FFF ADR S ; }    
defines a macro called READRAM. 
 
{{COMMENTS} 
 Whenever the word immediately following : is entered the result 
is the same as if the rest of the words up 
to ; were entered.  After typing in the example above, the word 
READRAM will have the same effect as entering " ONLY READ 1000 TO 
1FFF ADR S ."  To preserve the macro definition, you must 
SAVE-SYS before leaving the UniLab program. 
 
See also appendix F. 
~;`no parameters       Macro Sys 
      
Ends a macro definition started by : . 
 
~<TST>`<value> ' <TST> !       Macro Sys 
 
Setting this constant to 1 will turn off the output of some 
messages and will leave on the stack many results which are,
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 n. 
 
 
{{USAGE} 
An example of the type of register control command available with 
a DEBUG package.  This command addresses the Z-80 internal 
register BC.  
Consult the Target Application Note for your processor-specific
software 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 DEBUG has gained 
control of your microprocessor.  See STEP-INTO or RB for more 
information on debug control.   
 
This is a typical register changing instruction format.  A 
similar command is provided for each of the processor's internal 
registers (except SP).  

No space appears between the  =  and the register name.  
~=EMSEG`<hex digit> =EMSEG       RARELY USED 
 
Sets A16-A19 context for subsequent EMENABLE statement(s). 
Determines which 64K "bank" of memory the emulated ROM will be 
in.   
You 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 address of the area in emulation ROM used by the 
ORION DEBUG software. 
 
{{USAGE} 
When your software uses the memory reserved by the ORION DEBUG 
software.  This command changes the location of both the overlay 
and the reserved area.  Use function key CTRL-F3 to find the 
current address of the reserved and overlay area. 
 
You can instead disable the DEBUG features for completely 
transparent operation.  See RSP'. 
 
You must SAVE-SYS to make the change permanent. 
 
 
{{EXAMPLES 
 
2310  =OVERLAY} 
Moves the reserved area to start at 2310, and puts the overlay 
area above there. 
 
 
{{COMMENTS} 
The overlay area should not cross a 2K boundary.  Be careful when 
changing its location. 
 
~=PORT`<address> =PORT     
 
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     
 
Changes the length of the stimulus pulse from within the INSIGHT
panel (see REAL for more insight 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 making use of 
ALSO with ADR.  See the fourth example below. 
 
 
{{EXAMPLES 
 
NORMT 1023 ADR S } 
trigger on address 1023.  NORMT causes the trigger to appear at 
the Top of the trace.   
 
{NOT 120 TO 455 ADR S } 
trigger if address outside 120-455 range. 
 
{12345. ADR S } 
trigger on 20-bit address 12345.  The 1 will appear in right 
digit of the CONT column. 
 
{1200 ADR  ALSO 8 ADR  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. 
 
~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       SHIFT-F4 
 
Displays the handy reference ASCII table. 
 
{{USAGE} 
Shows each character, along with its decimal and hex value.  
 
 
{{EXAMPLE 
 
ASC} 
This command is never used in combination with anything else. 
 
 
{{COMMENTS} 
This 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.   
 
{{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, use OPEN 8620.SYS to close 
your file and re-open the menu prompt file.  If you don't do this, 
then some of the on-line help facilities and error messages will 
not work. 
 
 
 
{{EXAMPLES 
 
1200  1D 1F  ASM-FILE} 
loads assembly code, starting at address 1200, from screens 1D 
through 1F of the currently opened FORTH file. 
 
{1 4 ASM-FILE} 
loads code from screens 1 through 4, starting at the current 
value of ORG. 
 
~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. 

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.
 
~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.  
~BYE`no parameters 
 
Exits from UniLab program. 
 
{{USAGE} 
To return to DOS.  Use SAVE-SYS first, if you want to save the 
current state of the system.   
 
Use DOS instead if you want to execute just a few DOS commands 
and then return to the UniLab program. 
 
 
{{EXAMPLE 
 
BYE} 
     This command never used in combination with anything else.  
 
 
 
 
 
~CATALOG`no parameters 
 
Displays a directory of all the available pinouts-- the proper 
cable hook-ups for each microprocessor.  
 
{{USAGE} 
Once this word is entered, any of the listed pinouts can be 
displayed on the screen.   
 
This word "opens" the pinout library.   It closes again as soon 
as you enter another command. 
 
Until you use this command, the only pinout diagram available is 
that of the mp you are using.  You get that with the command 
PINOUT. 
 
~CKSUM`<from addr> <to addr>  CKSUM      
Calculates the checksum for a given range of memory.  Useful for 
error-checking. 
 
 
{{USAGE} 
A good way to make a PROM easy to check for burn-in errors, or 
corrupted locations.  Allows you to record the checksum of your 
program-- or better yet, make the checksum equal to zero. 
 
 
{{EXAMPLE 
      
     800 FFF CKSUM }   
prints a 16-bit checksum for the data in addresses 800-FFF 
 
{{COMMENTS} 
You may want to patch the complement of this value into your 
PROM.   You can produce a PROM with a checksum of zero, using the 
following method, which sacrifices only two bytes. 
   
First store zero where the checksum will be  
(0 FFE MM! in the above example). Second, find the checksum, 
using CKSUM.  Lastly, patch in the complement of the sum.   
 
For example, if the sum is 1234, then use the command 
-1234 FFE MM!.  The resulting PROM will have a checksum of 0.  
 
~CLEAR`no parameters       RARELY USED 
 
Clears the screen before performing a PgUp.  Use with some of the 
older color monitor cards, that will otherwise flicker when you 
use PgUp. 
~CLEAR'`no parameters       RARELY USED 
 
The normal default condition-- the screen is not cleared before a 
PgUp is executed.   Use only to restore the default condition 
after executing a CLEAR. 
~CLRMBP`no parameters 
 
Clears all multiple breakpoints. 
 
{{USAGE} 
Use to wipe the slate clean, and start out setting multiple 
breakpoints again.  SMBP sets the breakpoints. 
 
 
{{EXAMPLE 
 
CLRMBP} 
This command never used in combination with anything else. 
 
 
{{COMMENTS} 
Use to clear all the numbered breakpoints which you set with SMBP 
and can clear one at a time with  RMBP. 
 
~CLRSYM`no parameters 
 
Clears out the current symbol table. 
 
{{USAGE} 
When you want to get rid of the symbols that you have defined for 
your program.  It's a good idea to first save the symbols, just 
in case you decide you want those symbols after all.  See 
SYMSAVE. 
 
The symbol table also gets cleared by SYMFILE and SYMLOAD before 
they load in the new symbols.  SYMFILE+ adds to the existing 
symbol table. 
 
Unless you save the symbols, you cannot recover them later.  You 
could instead use SYMB', which turns off the symbol table without 
erasing it.   
 
 
{{EXAMPLE 
 
CLRSYM} 
This command never used in combination with anything else. 

~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 to AA0 (2720 decimal).  That 
delay count puts the trigger event near the top of the trace 
buffer, after the ten cycles that came just before it.  
 
{{WHY YOU MIGHT WANT TO} 
You might want to see the trace starting 260 cycles after a known 
event-- perhaps you don't know where the program ends up at that 
time.  The DCYCLES command will do the job perfectly. 
 
 
{{EXAMPLE 
 
104 DCYCLES} 
selects 104 (hex) delay cycles (260 decimal) 
 
 
{{COMMENTS} 
NORMT, NORMM, and NORMB select AA0, 555, and 4 DCYCLES 
respectively.  S+ increases the number of delay cycles by AA6, 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 0 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. 
See STEP-INTO and RB. 
 
~DMBP`no parameters  
 
Displays the settings of all eight multiple breakpoints. 
 
{{USAGE} 
When you forget the settings of your multiple breakpoints.   
Automatically executed whenever you set one of the 8 multiple 
breakpoints with SMBP. 
 
 
{{EXAMPLES 
 
DMBP} 
This command never used in combination with anything else. 
 
~DN`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. 
 
~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
 
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
 
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              
 
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. 
 
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.  Exits DEBUG control, lets the 
target run. 
 
{{USAGE} 
After you have set a breakpoint, and want to release debug 
control and let the target run.  G is one of several ways to do 
this. 
 
G just gets the target board going.  After that, you can enter a 
trigger spec and restart the analyzer, or you can use one of the 
"big picture" words: ADR?, SAMP, or NOW?. 
 
You could instead use STARTUP to restart the analyzer and the 
board at the same time.  Or use NORMx followed by a trigger 
specification and S, to restart the analyzer and give you a trace 
of the event that you describe.  
 
 
{{EXAMPLE 
 
1030 G} 
exits from debug control, and resumes the target program at 
location 1030. 
 
 
{{COMMENTS} 
Appropriate if you have a DEBUG package and have established 
control by entering RESET adr RB, or STEP-INTO.  You can return to
any 
point in the program you like, but debug control will be lost.   
 
Use GB if you wish to resume the program at an address different 
from the one you are stopped at but with another breakpoint set. 
 
~GB`<addr to go to> <bpoint addr> GB                 
Goes to the first address, and starts executing code, with a 
breakpoint set at the second address. 
 
{{USAGE} 
When you want to move around the program without losing debug 
control. 
 
 
{{EXAMPLES 
 
1200 330 GB} 
resumes the program at address 1200, with a breakpoint set at 
330.  
 
 
{{COMMENTS} 
Available if you have an DEBUG package and have established DEBUG 
control. See RB to establish DEBUG control. 
 
~GW`<address> GW 
 
Goes to the indicated address and waits until the analyzer is 
started.  Releases the target board from DEBUG control. 
 
{{USAGE} 
To continue the execution of the program, starting at the given 
address, after a new trigger spec has been defined. 
 
A rather specialized but very useful command. 
 
 
{{EXAMPLE 
 
1100 GW  NORMT 1200 ADR S} 
Goes to address 1100 and waits for the analyzer to be started.  
The trigger spec command sets the analyzer to capture a trace 
showing the code at address 1200. 
~H>D`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. 
~HDAT`HDAT FILTER       RARELY USED  
 
Used before FILTER to set up a filter spec based only on the high 
byte of the DATA inputs (D8 - D15). 
 
{{USAGE -- RARELY USED} 
You will probably never use this command.  Triggers on the full 
specification, but filters based only on the 8 bits D8 through 
D15.   
 
The filter mechanism of the UniLab gets turned on for you by the 
xAFTER macros.  Those commands set the filter to MISC' FILTER, 
which allows  you to set up a trigger spec based on all inputs 
except for the MISCellaneous wires. 
 
See also CONTROL, MISC' and NO. 
 
{{THE HIGH DATA INPUTS} 
These lines read from the high byte of the 16-bit data path of 
16-bit processors.  On 8-bit processors, the lines can be left to 
float, or be used to sense other logic signals on your target 
board. 
 
{{USAGE} 
Used to show only the cycles that meet your description.  While 
deciding whether to include the current cycle in a filtered 
trace, the UniLab will check only these 8 bits of the 48 inputs. 
 
A good way to look at all the bus cycles that have some specific 
data value as the upper byte of data. 
 
 
{{EXAMPLE 
 
NORMT HDAT FILTER 80 TO FF HDATA 3410 ADR A7 DEVENTS S} 
will give a trace showing only those cycles with D15 high, 
starting with the bus cycle that has D15 high and address 3410.  
You have to use DEVENTS to get a trace full of the event you are 
filtering on. 
~HDATA`< byte > HDATA 
            < byte >  TO  < byte > HDATA 
          < byte >  MASK  < byte > HDATA 
Changes the analyzer trigger for the high byte of 16-bit data 
path (D8 through D15).   Spare inputs on 8-bit processors. 
 
{{THE DATA INPUTS} 
The UniLab gets both the address and the data from the bus during 
each bus cycle.  The "data" that appears on the bus could be 
either a value or a machine code instruction.  On 8-bit 
processors the inputs D8 through D15 can be hooked up to anything 
you like. 
 
{{USAGE}  
The simplest use sets up a trigger for a single value on the high 
order byte of the data inputs.  The UniLab will search for the 
byte value, and trigger when it sees that hex number on the bus 
as data.   
 
Note that just looking at the high order byte means the UniLab 
doesn't care about the low order byte, and so it actually 
searches for a range of values.  See the first example below. 
 
To specify just one full 16 bit wide data value, you must use 
both HDATA and DATA. 
 
{{RANGES OF DATA} 
TO lets you set up a trigger on any data between two byte values, 
inclusive.   See the third example below.  
 
{{NOT} 
NOT causes the UniLab to trigger when the value falls outside the 
specified range or value.     
 
{{MASKING} 
You can use <i> MASK <j> HDATA to examine any subset of the 8 
most significant data lines.  The high bits of i mark which bits 
will be examined, while the bit configuration of byte j indicates 
the values the lines must have for a trigger to occur. 
 
For example, 01 MASK FF HDATA selects only 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 on on-line
help resources.  Press ALT-F1 or CTRL-F1 for additional help. 
SHIFT-F1 displays the current "easy macros."
 
{{USAGE} 
Look up information on a command, in the abridged on-line command 
reference.   See also WORDS. 
 
{{EXAMPLES 
 
HELP} 
displays help screen. 
 
{HELP BYE} 
gives information on command "bye." 

~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 have first 
established debug control.  To do that you must first have a 
program already loaded into emulation memory (LTARG for example) 
and then run to a breakpoint with RESET <address> RB.   
 
If DEBUG is not in control, attempts to load memory that is not 
enabled will generate an "auto-breakpoint."  You will see "-nmi-" 
and then the "target address-not enb" message.  Enabled areas in 
the same file will be loaded. 
 
 
{{EXAMPLE 
 
HEXLOAD MYPROG.HEX} 
  load an Intel HEX format file called MYPROG.HEX. 
 
 
 
 
 
{{COMMENTS} 
Only record types 0 to 3 are supported.  Bytes 7 and 8 of each 
line of the file tell what record type that line uses. 
 
16-bit processor note:  If the UniLab detects a type 2 (extended 
address) record then address bits A16-A19 will be compared to the 
current =EMSEG and data will not be loaded if it is intended for 
some segment other than the current one.  This will be indicated 
by a "not enb" message for each invalid address.  Enabled addresses
in 
the file will be properly loaded. 

See also FILES.
~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. 
 
 
{{COMMENTS} 
Obscure, but highly useful in some situations.   
 
Press ESC to stop the search. 
~INIT`no parameters  
 
Sends an initialization message to the UniLab. 
 
{{USAGE} 
To reset the UniLab after you are in the UniLab program.   
 
When you start up the program, it 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 any commands to the 
instrument. 
 
Also, if the UniLab was not properly connected when you called up 
the program, or if you turned off the UniLab at any time during 
the program, then the UniLab needs to be initialized. 
 
{{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        
Easy access to the Insight display panel.

{{USAGE} 
Places you in the Insight panel, setup to poll the processor at any
address.
See also REAL, to access Insight with a more restrictive address
specification.
 
{{EXAMPLE 
 
INSIGHT} 
This command is never used in combination with anything else.   
~INT`no parameters       RARELY USED 
 
Generates the NMI- interrupt output when trigger state reached.  
The NMI- wire from the UniLab must be connected to either NMI or 
IRQ circuit of processor. 
 
{{USAGE-- RARE} 
Useful for causing the target system to execute an interrupt 
routine when it goes into trigger search state (i.e., after the 
"qualifier has been found).  Used to prevent damage to equipment 
by branching control to a "soft shutdown" routine when some error 
condition occurs.  
 
You must write and install your own shutdown routine. 
 
Orion DEBUG packages use this command internally.  If you want to 
make use of it, you must disable the 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. 
 
{{USAGE} 
Rare. 
 
 
{{COMMENTS} 
Not often used since NORMx also disables the INT mode. 
~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 disassemblies.  If  
you already have an assembler generated symbol table, you will 
prefer to use the symbol table features of the UniLab.  See 
FILES, LOADER, SYMFIX and SYMFILE. 
 
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, and SYMFILE.   
 
~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, SYMLOAD,
and 
SYMFILE.   

~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 disassemblies.  If  
you already have an assembler generated symbol table, you will 
prefer to use the symbol table features of the UniLab.  See 
FILES, LOADER, SYMFIX and SYMFILE. 
 
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, and SYMFILE. 
 
 
~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 FILES, LOADER, SYMFIX and SYMFILE. 
 
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, and SYMFILE.   
 
~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, or from
the SYMTYPE menu within the UniLab with the choice "Additional
formats supported" (function key nine). 

{{Formats processed by LOADER}
This release will load in four different types of files, as shown
by the menu:

F1 OMF51  -- Intel Object Module Format for the 8051 family.(o s)
F2 OMF86  -- Intel OMF for the 88/86 family.(o s)
F3 TEKHEX -- Tektronix Hex. (o)
F4 MOTORS -- Motorola S records. (o)
F9 Go to LOADER command mode.
F10 EXIT from LOADER
       s = symbols    o = object code

The loader always makes two passes through the file, and keeps you
informed of the loading status.   

{{Process a file from the menu}
Press a function key -- you will be prompted for the file name. 
After the file has been processed, the LOADER program terminates,
returning you to DOS or to the UniLab system. 

{{Invoke the LOADER with command line arguments}
The loader takes the following command line arguments:
  -O <filename>                 changes output filename
  -D                            eliminates duplicate symbols
  -E                            report all errors and warnings
  <load command> <filename>     load (process) a file
       The four load commands are:
       OMF51     OMF86     TEKHEX    MOTORS
and the load command must be the last command line argument.

For example:
       C> LOADER -O VERS02   -D   OMF51 SIEVE.OBJ 
will process file SIEVE.OBJ, eliminate duplicate symbols, and
create output files VERS02.BIN and VERS02.SYM.  

When you invoke the loader with command line arguments, it will
exit to DOS upon successful completion of the load.{{Process a file with commands from within LOADER}
You can enter any of the command line arguments after you've
entered the loader.  First, press F9 to enter command mode, then
enter any command. Command mode allows you to look back over a
record of the loading process (see next page).   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.

The first release of the LOADER supports four formats: 
absolute Object Module Format (OMF) for the 8051 family, 
OMF for the 8086 family, 
Tektronix Hex (but not yet extended TekHex), 
and Motorola S records. 
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. 
 
~LP`no parameters 
 
Goes around a loop once and stops. 
 
{{USAGE} 
You must already have established debug control  
(see RB), and be stopped at a breakpoint within a loop. This 
command allows the program to run once around the loop and stop 
at the current address, displaying the registers as the UniLab 
does for any breakpoint. 
 
{{WATCH OUT} 
Will not work if the program counter register is pointing above 
the first instruction or below the last instruction in the loop.  
Only works when you are within the loop.  See the Target 
Application Note for your processor for any additional 
restrictions. 
 
{{EXAMPLES 
 
LP} 
This command never used in combination with anything else.  
 
{{COMMENTS} 
Works by first saving the current breakpoint address, executing
STEP-OVER (a single step without following branches) and then
executing <savedaddress> RB.  Processors with multiple byte
breakpoint 
opcodes will 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.  Can change RAM, but only after establishing debug
control.  See RB. 
 
 
{{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. 
 
As with all memory writing commands, don't write into your stack 
area when loading into RAM. 
 
~M!`<byte> <address>  M! 
 
Stores a byte of data at the specified address. 
 
{{USAGE} 
Used to patch program memory.  Does not require a previous ORG 
command-- instead requires an address as the second parameter.  
See M.   Can also be used to change RAM, but only after debug 
control has been established. See RB. 
 
 
{{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 Appendix F of this manual.   See also EDIT_MACROS, for
information on simple macros.

For information on internal commands and other subjects, order the
UniLab Programmer's Guide from Orion. 
 
Several otherwise unused files must be in the UniLab directory 
when you request that the software switch to macro system.  
Included on your distribution diskette are the files necessary 
both for the operator system, with a .OPR extension, and for the 
macro system, with a .MCR extension.   You should have one .OPR 
and one .MCR file for every .EXE or .OVL file.   
 
When you switch to macro system, the UniLab software will search 
for a .MCR file whose name matches the current .EXE file.    
 
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 
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 file is 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 wires(M0 to M7). NORMx turns this mode 
off. 
 
{{WHY YOU DON'T NEED TO BOTHER} 
Because this is taken care of for you by ONLY and by xAFTER, so 
it is unlikely that you will need to use this command. 
 
See also CONTROL, HDAT, and NO. 
 
 
{{EXAMPLE 
 
MISC' FILTER } 
enables filtering on all inputs except M0-M7.
~MLOADN`<start> <end> <targ addr> MLOADN       RARELY USED 
 
Moves a block of memory from the memory of the host to the target 
memory. 
 
{{USAGE} 
Allows you to assemble or load a program into host memory, and 
then move it to UniLab emulation ROM or target RAM.   
 
Most people will prefer to assemble into a file, and then load 
from the file into UniLab emulation memory. 
 
{{FREE MEMORY} 
The host memory area that is available generally starts right 
above C000.  PAD 100 + U. displays the first free address.  SO U. 
shows you the upper limit of the unused memory. 
 
 
{{EXAMPLE 
 
C000 C800 0 MLOADN } 
moves data at C000-C800 in the host computer to target locations 
0-800. 
                          
 
{{COMMENTS} 
You must have emulation memory enabled to load the program into 
ROM (see EMENABLE).   
 
~MM`<word> MM 
 
Stores one 16-bit word in ROM or RAM and increments reference 
address. 
 
{{USAGE} 
Used after an ORG statement (which sets up reference address), 
to patch program memory.  Can be used to change RAM after debug 
control has been established. 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, but only after debug 
control has been established. 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 Non-Maskable Interrupt vector installation. 
  
{{USAGE} 
This command re-enables the UniLab's ability to perform STEP-INTO. 
You  
only want to disable this feature when you want more transparent 
operation and don't need to use all DEBUG features.  See RSP' for 
complete transparency. 
 
Normally you will use the MODE panel (function key 8) when you 
want to change this feature. 
 
~NMIVEC'`no parameters       F8 
 
Disables the STEP-INTO function (Non-Maskable Interrupt vector
installation). 
  
{{USAGE} 
This command disables the UniLab's ability to perform STEP-INTO.   
 
Normally you will use the MODE panel (function key 8) when you 
want to change this feature. 
 
The DEBUG features include the ability to send either a non- 
maskable interrupt (NMI) or an interrupt request (IRQ) to the 
microprocessor.  Orion software packages use this feature to gain 
DEBUG control over your processor at any time.   
 
{{WHEN YOU WILL WANT TO DISABLE STEP-INTO} 
When your system makes use of the NMI or IRQ, and you want to 
preserve that ability while testing the system. 
 
 
{{COMMENTS} 
Either the panel toggle or NMIVEC re-enables the vector 
installation. 
~NO`NO FILTER       RARELY USED 
 
Used before FILTER to disable the filter. 
 
{{USAGE -- RARELY USED} 
You will probably never use this command.  Used only when you 
want to turn the filter off while preserving the current trigger 
spec. 
 
The filter mechanism of the UniLab gets turned on for you by the 
xAFTER macros.  Those commands set the filter to MISC' FILTER, 
which allows  you to set up a trigger spec based on all inputs 
except for the MISCellaneous wires. 
 
See also CONTROL, HDAT and MISC'. 
 
 
{{EXAMPLE 
 
NO FILTER } 
turns off the filtering of bus cycles, but leaves the rest of the 
trigger spec untouched. 
 
~NORMB`no parameters 
 
Clears out (NORMalizes) all trigger descriptions and sets the 
trigger event near Bottom of trace buffer. 
 
{{USAGE} 
To start a new trigger definition when you want to see the events 
that led up to the trigger. 
 
Use TSTAT to look at how this command changes the DCYCLES 
setting. 
 
When you want to start from scratch with a new trigger 
description, always begin with one of the variations of NORM.  
The three commands, NORMB, NORMM, and NORMT, vary only in where 
within the trace buffer they place the trigger event-- at the 
bottom, in the middle or at the top. 
 
{{TO SEE WHAT HAPPENS NEXT} 
S+ restarts the target board with the same trigger specification, 
but with 2726 (decimal) added to the delay cycle count, so that 
you can see what happened after the current trace window. 
 
{{HOW THEY WORK} 
The commands clear out the truth tables the analyzer used to 
search for the trigger event, and set the number of delay cycles 
that the analyzer will wait between seeing the trigger and 
freezing the buffer.  See DCYCLES for more information about 
delay cycles. 
 
 
{{EXAMPLES 
 
NORMB} 
 Sets 4 delay cycles 
 
{NORMB NOT 0 TO 1000 ADR S     } 
will show what happened before the address went outside of the 
0-1000 range. 
 
 
{{COMMENTS} 
NORMB should be used where you want to know what happened before 
the trigger.   
~NORMM`no parameters 
 
Clears out (NORMalizes) all trigger descriptions and sets the 
trigger event at Middle of trace buffer. 
 
{{USAGE} 
To start a new trigger definition when you want to see the events 
that led up to the trigger, and also see what followed.   
 
You will find it very useful when you want to see the complete 
context within which the trigger occurred. 
 
Use TSTAT to look at how this command changes the DCYCLES 
setting. 
 
See NORMB for more details. 
 
 
{{EXAMPLE 
 
NORMM} 
sets delay cycles to 1365 (decimal). 
 
~NORMT`no parameters 
 
Clears out (NORMalizes) all trigger descriptions and sets the 
trigger event near Top of trace buffer. 
 
{{USAGE} 
To start a new trigger definition when you want to see the events 
that followed the trigger. 
 
Use TSTAT to look at how this command changes the DCYCLES 
setting. 
 
See NORMB for more details. 
 
 
{{EXAMPLE 
 
NORMT} 
sets delay cycles to 2720 (decimal). 
~NOT`NOT  <trigger description> 
 
The trigger description gets interpreted as a description of when 
not to trigger. 
 
{{USAGE} 
To tell the analyzer to trigger when some byte of the 48-channel 
input bus goes outside of a certain range or value.  Most 
commonly used to trap bad data or a bad address. 
 
 
{{EXAMPLES 
 
NORMT   NOT 00 TO 4FF ADR S } 
triggers if the address goes outside the 00 to 4FF range.  
 
{ONLY 127 ADR NOT 12 DATA S } 
shows only cycles where the data at 127 address is not 12.  
 
{NORMM   NOT 12 DATA  ALSO   NOT 34 TO 56 DATA  S} 
triggers when the data is not either 12 nor between 34 and 56. 
 
 
{{COMMENTS} 
Sets a flag for the next trigger word (ADR, CONT, DATA, HADR, 
HDATA, LADR, and MISC).  
 
Except when used with ALSO, the NOT command causes the truth 
table to be cleared to all 1's.  Then 0's get written into the 
specified areas.  This is the opposite of what happens without 
NOT. 
 
With ALSO, the NOT command does not clear out the truth table 
first. 
 
~NOW?`no parameters 
 
Shows you what is happening on the target board right now. 
 
{{USAGE} 
To see the code the microprocessor executes during the next 2730 
bus cycles.  
 
 
{{EXAMPLES 
 
NOW?} 
 This command never used in combination with anything else.  
 
 
 
{{COMMENTS} 
This command is a simple macro that turns off the RESET, so that 
it does not restart the target board, then sets its own trigger 
and captures a trace. 
                    
~NX`no parameters     
 
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 STEP-INTO 
enabled, you can alter RAM at any time, since the Orion software 
will automatically gain DEBUG control, read the RAM and then 
resume execution of the target program. 
 
If you disable 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. 
 
 
{{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. 
 
~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.  Must be used with RESET enabled to establish debug
control. 
 
{{USAGE} 
The first breakpoint must be in emulated ROM, and come after the 
stack pointer has been initialized.  
 
You can also use STEP-INTO or RI and SI to establish debug control.

 
{{MISSED BREAKPOINTS} 
If the breakpoint is not reached, then the program will continue 
to run until you press any key.  Pressing a key while waiting for
breakpoint causes the UniLab to try to STEP-INTO your program.  

If you fail to establish debug control, you must then use RESET
<address> RB to gain debug control.  You can only set a breakpoint
on the address of the first byte of an instruction.  
 
To make certain that the address you try to set a breakpoint on
gets 
executed by the program, set an analyzer trigger on the same 
address with NORMT <address> AS.   
 
And make sure that your program does initialize the stack pointer 
to point at RAM.  DEBUG uses the stack to save the state of your 
system. 
 
 
{{EXAMPLES 
 
RESET 123 RB } 
enables reset, and then restarts the target system with a 
breakpoint set at address 123 

{1007 RB} 
without restarting the target system, run the program with a 
breakpoint set at address 1007. 
 
 
{{COMMENTS} 
The second example above will work only if you have already 
established DEBUG control.   
 
The first example will establish DEBUG control, as will an STEP-
INTO 
command.  RESET does not restart your target board-- it enables 
the "reset" flag, so that the S or RB which follows restarts the 
target. 
~READ`no parameters 
 
Narrows the trigger specification to read cycles only. 
 
{{USAGE} 
Instructs the UniLab to trigger only on read cycles.  Handy when 
you want to trigger on data memory values, not program memory 
opcodes.  Or, when you want to trigger on reads rather than 
writes to some address range. 
 
On some disassembler packages, FETCH instructs the UniLab to 
trigger only on fetches from program memory. 
 
 
{{EXAMPLES 
 
READ 13 DATA } 
sets up to trigger when microprocessor reads a 13. 
 
{NORMT READ 1000 TO 2000 ADR S} 
triggers when processor reads any data from address range 1000H 
to 2000H.                                    
 
{{COMMENTS} 
A simple macro which specifies a range of CONT input values. This 
command, like WRITE and FETCH, gets defined for a particular 
processor by the optional disassembler. 
~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.

~REAL` <address specification> REAL        
 
Places you in the INSIGHT panel.
 
{{USAGE} 
Access to the new real-time INSIGHT display.  

The address specification tells REAL the addresses where you want
to see the state of the processor.  The command INSIGHT is the same
as RESET ANY REAL.


{{EXAMPLES 
 
RESET' 1834  REAL} 
will not reset the processor.  Will update the display
panel whenever address 1834 appears on the bus. 

{RESET 100 TO 120 REAL}
will reset the processor once and then update the display
panel whenever an address in the range 100 to 120 appears
on the bus. 
~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: establish 
DEBUG control before you access emulation memory.  That way, your 
processor will be held in the idle loop while you access 
emulation ROM. 
 
 
{{EXAMPLES 
 
RES- 10 DN} 
pulls the reset line low and then disassembles from memory, 
starting at address 10.  Reset will stay low until the next time 
you start the analyzer. 
 
{RES- 500 ASM} 
pulls the reset line low, then invokes the assembler, starting at 
address 500.  
~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 
 
Selects automatic reset mode, which resets the target system when 
you next start the analyzer. 
 
{{USAGE} 
Along with RESET', allows you to choose whether to restart the 
target board when you start searching for a trigger, or just 
watch a program already in operation. 
 
To gain DEBUG control with RB you must enable reset. Always type 
RESET <address> RB to be sure. 
 
Automatic reset gets turned on by STARTUP, and gets turned off by 
NOW, ADR?, SAMP, and RB.  The status of reset is not affected by 
NORMx. 
 
Normally you will use the MODE panel (function key 8) when you 
want to change this feature. 
 
 
{{EXAMPLE 
 
RESET} 
selects auto-reset  
 
~RESET'`no parameters       F8 
 
Turns off the automatic reset mode. See RESET above. 
 
{{USAGE} 
Normally you will use the MODE panel (function key 8) when you 
want to change this feature. 
 
~RI`RI  <trigger spec> SI  
 
Allows you to gain DEBUG control when any 
trigger specification occurs.
 
{{USAGE} 
To gain debug control on a data value, or a control column value, 
or a range of address values.  Always used in combination with 
SI.  RI marks the beginning of the trigger specification, SI 
marks the end. 
 
When the bus state you specify occurs this feature asserts a STEP-
INTO signal.  Generally, it takes one or two instructions cycles 
to gain debug control. 
 
 
{{EXAMPLES 
 
RI 450 TO 470 ADR SI} 
Will achieve DEBUG control after any address in the range 450 to 
470 appears on the bus. 
 
{RI WRITE  34 DATA SI} 
Will achieve DEBUG control after the value 34 is written into 
RAM. 
 
~RMBP`<break point #> RMBP 
 
Resets (clears) one of the multiple breakpoints and displays new 
status of the multiple breakpoints. 
 
{{USAGE} 
When you want to get rid of one of the breakpoints that you set 
with SMBP. 
 
See also CLRMBP, which clears out all the multiple breakpoints. 
 
 
{{EXAMPLE 
 
3  RMBP  } 
clears multiple breakpoint number 3. 
 
 
{{COMMENTS} 
Multiple breakpoints are used with to break on more than one 
address.  There are 8 multiple breakpoints available in addition 
to the standard (unnumbered) breakpoint set by RB or  GB.   
 
~RSP`no parameters       F8 
 
Re-enables DEBUG, after it has been disabled by RSP' or EMCLR. 
 
{{USAGE} 
Only when you have turned off the DEBUG features, and now want to 
be able to use it again.  Not the same as establishing debug 
control, which you do with 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.  
Debug control will be lost. 
 
{{USAGE} 
When you want to run the program starting from the current 
address.  
 
A handy command for exiting from DEBUG control.  However, a 
better command is GW which waits until you start the analyzer, so 
that you can start the program from the breakpoint with a trigger 
set. 
 
 
{{EXAMPLE 
 
RZ} 
Continues the program after a breakpoint. 
 
 
{{COMMENTS} 
Don't try to specify a trigger event before RZ-- it will not 
work. 
 
~S`no parameters 
                     
Starts the bus state analyzer.  Resets the target system if 
automatic RESET is enabled.   
 
{{USAGE} 
You do not need to start the analyzer on the same line as the 
command that sets up the trigger event specification, though that 
is the usual practice.   
S is a separate command that gets the analyzer going with 
whatever spec you created already in place. 
 
You can use TSTAT to see what the trigger has been set up to 
(Trigger STATus). 
 
 
{{EXAMPLES 
 
S} 
Starts the analyzer, with whatever trigger was last defined. 
 
{NORMT RESET 123 ADR S } 
clears out the trigger spec, turns on auto-reset, and then sets 
it to address = 123 before starting the analyzer (and restarting 
the target board). 
~S+`no parameters 
 
Identical to S, except that it increases the delay cycle count  
by 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.  
All S+ does is change the value of DCYCLES and then start the 
analyzer again. 
 
So if your trigger spec only happens once in the program, and 
RESET is disabled, then the UniLab will be searching a program in 
progress for an event that has already occurred.  
 
 
{{EXAMPLE 
 
S+ } 
restarts the analyzer with an increased  delay setting. 
 
~SAMP`no parameters 
 
Samples the 48 input lines several times a second, and displays 
them until any key is pressed. 
 
{{USAGE} 
A good way to get a vague idea of what is going on.  It will be 
clear to you that the program has been stuck in an infinite loop, 
or that it has gone far astray.  But you will not be able to tell 
much, as you only see one cycle out of every several thousand. 
 
{{DISASSEMBLY} 
You will probably want to turn off the disassembler, with the 
Mode Panel (F8) or DASM'.  When the disassembler is enabled the 
isolated cycles will probably be disassembled incorrectly.  
 
 
{{EXAMPLE 
 
SAMP} 
This command never used in combination with anything else.        
                   
 
 
{{COMMENTS} 
Useful when you are trying to connect analyzer inputs to 
something and you want to continuously monitor their state.  
Similar to 1 SR but it runs faster.  Gives more detail on program 
execution than ADR?.  Don't forget to start from scratch on 
trigger specs after using SAMP, because it defines its own 
trigger.   
 
It also turns off the RESET.  
 
~SAVE-SYS`SAVE-SYS <file name> 
 
Saves the entire UniLab system program in its present state as a 
named DOS file.  Prompts you for file name if you do not include 
it on command line. 
 
{{USAGE} 
To save a version of the system with new macros, or with default 
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 Appendix F for examples. 
 
 
{{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 gain DEBUG control on any bus condition. 
 
{{USAGE} 
Always used in combination with RI.  Please consult the reference 
section on RI. 
 
~SMBP`<addr>  <breakpoint #> SMBP 
 
Sets one of the 8 multiple breakpoints at the given address. 
 
{{USAGE} 
Allows setting of up to 8 breakpoints, in addition to the 
unnumbered breakpoint that is set by RB or GB.  The status of all 
8 breakpoints gets displayed each time you set or clear one.   
 
You must already have debug control before you issue this 
command. 
 
To use multiple breakpoints, set all but one of your breakpoints 
with this command, and then use RB or GB to get the target 
program going again. 
 
 
 
{{EXAMPLES 
 
123 4  SMBP} 
          sets a breakpoint #4 at address 123. 
 
250 RB} 
sets a breakpoint at 250 and starts the target program going 
again. 
 
{{COMMENTS} 
See also 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 
 
Enables the optional Program Performance Analyzer for the new 
command file that it creates.  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. 
 
~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.  
 
~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. 
 
~SSTEP` See STEP-INTO, STEP-OVER. 
~STARTUP`no parameters       F9 
 
Restarts the target system and gives a trace of the first 170 
cycles of target system operation. 
 
{{USAGE} 
Very useful mode at the first stages of system checkout.   Allows 
you to check out the first few instructions, make certain that 
they execute properly.  
 
The RES- wire from the analyzer cable must be properly connected 
to the target system, or the UniLab will not be able to reset the 
target processor.  See the Installation chapter of the User 
Manual.   
 
The very first cycle (cycle 0) is particularly important because 
if correct data is not fetched (often due to the address not 
being properly EMENABLEd), then the program will immediately 
"blow up."   
 
{{MULTIPLE RESET} 
Some systems with simple R-C reset circuits (no hysteresis) will 
appear to reset intermittently many times before they finally 
settle down to stable operation.  This is a nuisance if you want 
to look at a trace early in the program, but you will be able to 
see the program when it does finally settle down.  
 
If your system does this, you might want to consider putting a 
logic element-- such as two Schmitt triggers in a row (part 
number LS14)-- into your reset circuit.  That way your system 
will always get a good strong reset signal. 
 
{{EXAMPLES 
 
STARTUP} 
This command never used in combination with anything else.  
 
{COMMENTS} 
This is a target specific macro that usually looks for the reset 
vector address on the bus.  If that address does not show up, 
system will wait forever.  Or if a HALT instruction is fetched, 
will give a "NO ANALYZER CLOCK" message.  See TroubleShooting 
chapter. 
~STEP-INTO`no parameters       F4 
 
Either establishes DEBUG control immediately or, if you already 
have DEBUG control, executes a single instruction. 
 
{{USAGE} 
Now supported on all DEBUG software packages.   Uses either the 
non-maskable interrupt pin (NMI) or the interrupt request pin 
(IRQ) of the target processor. 
 
Allows you to establish debug control on a program that is 
currently running.  See also RB and RI.   
 
{{AUTO-BREAKPOINT} 
You can now read or write RAM and I/O without first gaining DEBUG 
control-- the UniLab will automatically do it for you.  When you 
try to read RAM while a program is running, the UniLab will issue 
an NMI signal, gain DEBUG control, perform the requested function 
and then allow the program to resume. 
 
{{SINGLE-STEPPING} 
After you have established DEBUG control, the 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. 
 
{{COMMENTS} 
The hardware interrupt feature is also utilized by SI.  Disabling 
STEP-INTO also disables that feature. 
~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 after DEBUG control has been established. 
~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, SYMFILE, or SYMLOAD,  all of 
which will turn on symbol translation. 
 
~SYMB'`no parameters       F8 
 
Disables the symbol translation feature. 
 
{{USAGE} 
To turn symbol translation off without clearing out the symbol 
table.  See CLRSYM if you want to clear out the table. 
 
Normally you will use the MODE panel (function key 8) when you 
want to change this feature. 
 
~SYMDEL` <number> SYMDEL 
 
Allows you to remove one symbol from the current symbol table.  
 
{{USAGE} 
Use SYMLIST first to get a list of all the symbols in order of 
increasing value.  This list of symbols is numbered.  You delete 
a symbol by using its number, not its value. 
 
{{EXAMPLE 
 
5 SYMDEL} 
Deletes the fifth symbol in the list that SYMLIST shows you. 
~SYMFILE`SYMFILE <file name> 
 
Loads a symbol table file produced by a cross assembler or cross- 
compiler. Prompts for a file name if you don't include it on 
command line. Or, use the FILES dialog box.
 
{{USAGE} 
Capable of loading symbol tables in almost any format.  The first 
time you use it, SYMFILE presents you with a menu of predefined 
formats.  You can choose one of those, and then save the system 
with SAVE-SYS to make that the default format. 
 
You can change the default format with SYMTYPE or with SYMSET. 
 
Formats not on the menu can be defined using SYMFIX for fixed 
length files.  Variable length files only come in two formats:  
name and then value, or value and then name.   
 
The AVOCET format on the menu is for symbol files that are name, 
then value.   
 
The MANX format on the menu is for symbol files that are value, 
then name. 
           
The MICROTEK format refers to "MicroTek/New Micro,"  not to 
"Microtec Research."   Symbol files with this format are produced 
by the 2500AD cross-assemblers, and include local symbols.   
 
The "Additional supported formats" option calls the standalone 
symbol/object file loader.  This loader can also be called 
directly from DOS, with the command LOADER.  It produces symbol 
and binary files, which must then be loaded into the UniLab 
system with SYMLOAD and BINLOAD. 
 
{{EXAMPLES 
 
SYMFILE C:\ASM\OUT.SYM} 
Loads into the UniLab a symbol file created by an assembler. 
~SYMFILE+`SYMFILE+ <file name> 
 
Appends the contents of a symbol file to the symbol table. 
 
{{USAGE} 
Provides a way of adding to a symbol table that already exists.  
SYMFILE, on the other hand, automatically clears the existing 
symbol table. 
 
SYMFILE+ allows you to combine several symbol tables. 
 
See also CLRSYM. 
 
 
{{EXAMPLES 
 
SYMFILE+ A:EXTRA.SYM} 
Adds to the symbol table the symbols stored in a file on the A 
drive. 
 
~SYMFIX`<a> <b> <c> <d> <e> <f>  SYMFIX 
 
Defines symbol file parameters for formats that use fixed length 
records.   
 
{{USAGE} 
Use this word to define your own SYMFILE format for fixed length 
records, if none of the predefined formats available on the 
SYMFILE menu suit your purposes.  There are only two types of 
variable length record formats (value then name or name then 
value) and both appear in the menu. 
 
The definitions of the 6 parameters: 
 
     a = offset from start of record to start of name field. 
     b = 1 if address is 4 ASCII digits or 0 if 16-bit binary. 
     c = address field offset from start of record.  
     d = 1 if binary address has most significant byte  first. 
     e = pad characters used to fill between symbols. 
     f = record length. 
 
 
{{EXAMPLES 
 
0 0 B 1 0 E SYMFIX  } 
defines the format for 2500AD abbreviated symbol table files. 
These tables follow the format: 
ten bytes for the symbol name, 
two bytes for the symbol value, 
two pad bytes. 
~SYMLIST`no parameters 
 
Shows you a numerically ordered list of all currently defined 
symbols. 
 
{{USAGE} 
To verify that your symbol file has successfully loaded in, or to 
remind yourself which symbols you have defined with IS.   
 
This command also gives you the information that you need to 
selectively delete symbols.  See SYMDEL. 
 
 
{{EXAMPLE 
 
SYMLIST} 
Lists all the current symbols. 
~SYMLOAD`SYMLOAD <file name> 
 
Loads a UniLab format symbol table file from the disk.  Prompts 
for you for file name if you don't include it on command line. 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. 
~SYMSET`<n> SYMSET         Macro Sys 
Chooses the symbol file formats that SYMFILE will expect. 
For use within macros. 
 
{{USAGE} 
Usually, before loading in a symbol file, you will use 
SYMTYPE to choose the format from an interactive menu.  
 
However, if you want to "hard code" a format in a 
macro, you need to use SYMSET.  
The syntax is <n> SYMSET, where <n> is a number 
corresponding to these symbol types: 
 
     1   2500AD SOFTWARE 
     2   2500AD SOFTWARE      (abbreviated) 
     3   ALLEN ASHLEY 
     4   INTEL ISIS-II (MCS-51 only ) 
     5   MICROTEK FORMAT      
     6   Don't use-- use SYMFIX instead. 
     7   MANX AZTEC C    (value, variable length name) 
     8   AVOCET          (variable length name, value) 
     9   Calls standalone LOADER 
 
 
{{EXAMPLE 
 
7 SYMSET} 
The equivalent of option seven on the SYMTYPE 
menu.  SYMFILE will now expect a symbol file with, 
on each line, a value followed by a variable 
length name. 
 
~SYMTYPE`no parameters 
 
Re-defines the file format assumed by the SYMFILE command.  Or, you
can use the FILES dialog box instead.
 
{{USAGE} 
Presents you with the symbol table format menu.  This allows you 
to choose a different format after you have chosen one with 
SYMFILE.  For setting a format in a macro, see SYMSET. 
 
The first time you use the SYMFILE command you are presented with 
a menu of formats.  Once you have chosen a format, SYMFILE 
executes immediately, using the selected format.  SYMTYPE allows 
you to alter your choice of format. 
 
See also SYMFIX, LOADER. 
 
The MICROTEK format in the menu refers to "MicroTek/New Micro,"  
not to "Microtec Research." 
 
{{EXAMPLE 
 
SYMTYPE} 
This command never used in combination with anything else.  
~T`no parameters                 
 
Displays the trace from its current starting point until any key 
is pressed. 
 
 
{{EXAMPLE 
 
T} 
displays the trace. 
 
 
{{COMMENTS} 
The current starting point for the trace display is defined by 
the most recent TN command.  (STARTUP usually sets it to -4.) 
 
If the starting cycle # is not actually in the trace buffer, the 
trace is started 4 lines from the closest cycle number which is 
in the trace buffer.   
 
~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. 
 
~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?     
 
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.  
