# 214 ; The length is the block length of this memory unit. If the length
    # is set by a register, this should be 0 or the amount to add to
    # that register.
    l*ength=V           \\ Inclusive Length (in memory units) of block
    # 314 ; The type of memory is dependent on the device type. Default is
    # normally mapped to a data space. Otherwise, a memory space may
    # be specified.
    *type=K(def*ault,prog*ram,dat*a,IO)0 \\ Type of memory space
    # 322 ; The access field indicates how the memory is to be treated. For
    # simulators, this affects the target use of the memory. For real
    # targets, this only affects how the debugger uses the memory and
    # will affect any generated link command files.
    *access=K(RAM,ROM,WOM,NOMEM,Auto,Prompt,Flash)0 \\ Access rules for memory
    # 263 ; The wait-states value is used with simulators to calculate the
    # cycles used when accessing this memory. The default is based on
    # the processor's own wait-state model for external memory. This value
    # will be noted when link command files are generated from this data
    # to allow careful positioning of sections to this memory.
    wait_states=V(0-32)0\\ Wait states to access this memory
    # 162 ; Additional attributes can be specified for the memory. These will
    # be used by the simulators and will guide the debugger in access to
    # this block of memory.
    {.Attributes        \\ Additional attributes of the memory
      # 280 ; This memory is internal to the processor core and not treated
      # as external. This affects wait-state timings and other factors.
      internal=B0       \\ True if internal memory to chip (ASIC specials)
      # 204 ; The access rule information is only used in simulators to control
      # timing issues. It will be noted if a link command file is
      # generated.
      access-rule=K(single,dual,dual-port)0 \\ Processor accessibility timings
      # 213 ; The access-size field allows control of how the memory is accessed
      # by the debugger internally. For external memory with only byte-wide
      # or half-word-wide access allowed, this can be used to insure proper
      # access to the memory. Depending on the processor, this may have no
      # effect at all.
      access_size=V(0-4)0\\ access size of memory
      # 222 ; 
      volatile=B0       \\ True if access will destroy contents
      # 221 ; The shared field indicates if the memory is shared with other
      # processors. If it is, it also indicates if directly shared (can
      # access directly via the bus) or indirectly shared (such as via
      # the host port of this processor). If this is set, the shared-with
      # field can be filled in to indicate what other processors or devices
      # see this memory.
      shared=K(none,direct,indirect)0 \\ Shared access rules
      # 321 ; The shared-id field is a number that is refers to this block of 
      # memory from any device. You must use the same number for each
      # device when referring to it. RVDEBUG will then correctly update all
      # device views when this memory is modified.
      shared_id=V       \\ Unique ID for this block from all devices.
    }
    # 147 ; The flash type field contains the name of a file containing the
    # RVDEBUG flash programming algorithm for this processor. With this file,
    # the flash can be downloaded-into or modified by RVDEBUG using the
    # special routine. Check the Web site for available Flash routines.
    flash_type=F(Flash Method Files [*.fme])    \\ Name of flash for auto-write
    # 273 ; 
    desc*ription=S"From ASIC/Board"\\ Description of memory space
    # 161 ; Register-Pos-Len is used when one or two memory-mapped registers 
    # are used to set the base address and/or length of the memory
    # block (such as for cross-bar switches, chip-selects, etc. These
    # are not used for enables which are set using Map rules (below).
    {.Register_Pos_Len  \\ Used for Register based position or size
      # 176 ; The register-base field allows a block of memory to be positioned
      # based on a memory mapped register. The value of the register is
      # added to the start field to construct the block start address. It
      # may be masked and scaled (multiplied or divided) first.
      register_base=K($TEMPL_GROUP=Register.,$TEMPL_GROUP=bit_fields.)\\ Name of register to add contents to start address
      # 175 ; 
      base_mask=V0xFFFFFFFF \\ mask to apply to register
      # 307 ; Base-scale is used to alter the value of the register contents
      # (after masking) to define the actual base. If the number is 
      # positive, it will be multipled against the register content. If
      # the number is negative, it will be divided from the register
      # content. Example: a byte register may select the 64K region to
      # map to; the scale would be 0x10000 (64K) so that the register
      # can be 0, 1, 2, 3, etc to select a 64K region. In the event that
      # the selector occupies part of a register, the mask is applied
      # to select only the selector portion and the scaling value itself
      # may be scaled. For example, using the example above: if the
      # byte selector portion is the upper byte of a register, we would
      # scale by 0x10000/0x100=0x100 (256). So, we mask with 0xFF00 and
      # multiple 256 to get a 64K selection.
      base_scale=V0     \\ signed scaling (neg means divide)
      # 262 ; The register-length field allows a block of memory to be sized 
      # by a register - this is commonly used in multi-processor shared
      # memory systems. The content of the register is added to the specified
      # length to compute the block length.
      register_length=K($TEMPL_GROUP=Register.,$TEMPL_GROUP=bit_fields.)\\ Name of register to read length from
      # 279 ; 
      len_mask=V0xFFFFFFFF \\ mask to apply to register
      # 174 ; The len-scale field is used like base-scale.
      len_scale=V1      \\ signed scaling (neg means divide)
      # 156 ; The len-table field allows table indexing for the length. The
      # length register is masked and scaled and then used as an index
      # in a table of values. The last value will be used if the scaled
      # register value is too large. The table value will be added to
      # the length field of the block.
      len_table=LV      \\ table of values to use for length.
      # 320 ; The update-rule indicates how often to check the register to see if
      # the mapping has changed. For cases where the mapping is set by jumpers
      # (which read as registers), it only needs to be inspected when first
      # connecting to the device. If the program changes it, it should be
      # tested on each stop.
      update_rule=K(init_time,update_init,stop_update)1 \
                          \\ Rules for when to test for map changes \K\
                          Test when connecting to device, \
                          Test on connect and when register is changed, \
                          Test on connect/change and execution stop
    }
    # 284 ; The volatile field allows defining ranges of a memory block
    # that is volatile on read (so will be marked specially in 
    # the memory window). The format is an offset from within
    # this block (0 relative). A range can be used such as 0x10..0x20
    # or 0x40..+4 can be used. If not a range, it will define a
    # single value.
    volatile=LS                 \\ Volatile memory range
  }
  # 160 ; The Map_rule entries are used to control enable/disable of memory
  # blocks. A register is named to be watched and when it matches a
  # given value, a set of blocks can be enabled. When it does not match
  # the value, a set of blocks can be enabled. The two sets of blocks will
  # alternate between enabled/disabled based on the value match.
  {Map_rule             \\ Define a rule for mapping memory (enable/disable)
    # 203 ; The register field is the name of a memory-mapped register that
    # controls the visibility of a memory block. This register is read to
    # determine the current mappings. It is generally better to name the
    # register itself instead of bit fields when more than one bit field
    # controls mapping (it optimizes the tests).
    register=K($TEMPL_GROUP=Register.,$TEMPL_GROUP=bit_fields.)\\ Name of register that we are testing
    # 291 ; The mask is and-ed to the register contents and the resultant value
    # is used to determine what is enabled or disabled.
    mask=V0xFFFFFFFF    \\ Mask to apply to register for test
    # 254 ; The value is compared with the register contents after the mask
    # is added. The comparison is straight "(reg-value & mask) == value"
    # so the value must have the bits in the right place. For example, if
    # bit 3 contains the enable information, the mask should be 0x8 (1<<3)
    value=V0            \\ Value to test for
    # 233 ; The On-equal field contains the name of one or more memory blocks
    # to enable when the value matches, or disable when it does not match.
    # To replace one block with another, create one rule that tests for
    # one value and another that tests for a different value. The most
    # common example is one that tests for the mask (reg&mask)==mask
    # and one that tests for 0 (reg&mask)==0.
    on_equal=LK($TEMPL_GROUP=Memory_block.)\\ Set of memory blocks to enable when equal (else disable)
    # 170 ; The update-rule indicates how often to check the register to see if
    # the mapping has changed. For cases where the mapping is set by jumpers
    # (which read as registers), it only needs to be inspected when first
    # connecting to the device. If the program changes it, it should be
    # tested on each stop.
    update_rule=K(init_time,update_init,stop_update)1 \
                        \\ Rules for when to test for map changes \K\
                        Test when connecting to device, \
                        Test on connect and when register is changed, \
                        Test on connect/change and execution stop
  }
  # 232 ; Enumerations are used when the register is shown in the register
  # window. By defining a set of names associated with values (e.g.
  # name or name=1), the names will be used to show the register contents
  # and for setting it. Bit fields of registers will be numbered 0,1,2...
  # no matter where they are positioned in the register.
  {Register_enum
    # 183 ; 
    names=LS            \\ name,name,... or name=value,...
  }
  # 182 ; Register Definition is used to add memory mapped registers provided
  # at the board or ASIC level. Each register is named and typed and may
  # be sub-divided into bit-fields (any number of bits) which act as
  # sub-registers.
  {Reg*ister            \\ Definition of Memory mapped registers.
    # 173 ; 
    *start=V            \\ Start address of register (in memory units).
    # 306 ; 
    l*ength=V(1-4)1     \\ Length (in memory units) of register.
    # 244 ; The base field controls how the start field is interpreted.
    # The default is Absolute (from 0), but can be relative to a
    # memory block (if the block is disabled, the register is too).
    base=K(Absolute,$TEMPL_GROUP=Memory_block.)0  \\ Start address base
    # 290 ; The type of memory indicates where the register memory comes from
    # on processors that have multiple spaces. Default is mapped to data 
    # space.
    memory_type=K(def*ault,prog*ram,dat*a,IO)0 \\ Type of memory space
    # 246 ; The register type field is used to define an explicit type for the
    # the register. If one is not specified, the default is the signed
    # scalar C type based on the register size.
    *type=K(s*igned,u*nsigned,p*ointer,f*loat,d*ouble,l*abel)0 \
                        \\ Type of register.
    # 305 ; 
    read_only=B0        \\ True if read-only register.
    # 261 ; 
    write_only=B0       \\ True if write-only register.
    # 202 ; Volatility indicates that the register has side-effects when accessed
    # (read or write). Common read side-effects are the data is lost (such
    # as pulled from a UART). Common write side-effects are the device 
    # takes some action on write (such as triggers a DMA). This information
    # is used in the register window.
    volatile=K(normal,on_read,on_write,on_both)0 \\ Volatility of register \
                      \K Not Volatile,Contents altered on Read,\
                         Side effect to Write,Side effect to any Access
    # 201 ; 
    enum=K($TEMPL_GROUP=Register_enum.)\\ Name of Register_enum to show values with
    # 243 ; 
    gui_name=S          \\ Optional name for showing in register window.
    # 141 ; 
    {bit*_fields        \\ Bit Fields within a Register.
      # 278 ; 
      pos*ition=V(0-32)0\\ Bit position from 0 (LSbit).
      # 200 ; 
      size=V(1-32)1     \\ Size in bits.
      # 199 ; 
      signed=B0         \\ True if signed vs. unsigned.
      # 253 ; 
      enum=K($TEMPL_GROUP=Register_enum.)\\ Name of Register_enumeration to show values with
      # 198 ; 
      read_only=B0      \\ True if read-only (cannot modify).
      # 242 ; Volatility indicates that the register has side-effects when accessed
      # (read or write). Common read side-effects are the data is lost (such
      # as pulled from a UART). Common write side-effects are the device 
      # takes some action on write (such as triggers a DMA). This information
      # is used in the register window.
      volatile=K(normal,on_read,on_write,on_both)0 \\ Volatility of register \
                        \K Not Volatile,Contents altered on Read,\
                           Side effect to Write,Side effect to any Access
      # 197 ; 
      gui_name=S        \\ Optional name for showing in register window.
    }
  }
  # 212 ; Concatenated Register Definition is used to add registers which are