DEBUG DEPOSIT — VMS 5.1-B
The DEPOSIT command is used to change the contents of memory
locations in your program. The value specified to the right of
the equal sign is deposited into the location specified to the
left of the equal sign. Type conversion will be done, if
necessary, according to the rules of the currently set language.
In other words, "DEPOSIT A = B" should have the same effect as
the assignment statement "A = B" in your program. (Note - for
PASCAL and ADA, substitute ":=" for "=" in the above sentence).
You can also change the assembly-language instructions being
executed using the DEPOSIT/INSTRUCTION command. See the
qualifier /INSTRUCTION for details.
Format:
DEPOSIT [/qualifier] address-expression = expression
DEPOSIT [/qualifier] address-expression := expression (PASCAL,
ADA)
Additional information available:
/ASCIC/ASCID/ASCII:n/ASCIW/ASCIZ/BYTE/D_FLOAT
/DATE_TIME/FLOAT/G_FLOAT/H_FLOAT/INSTRUCTION
/LONGWORD/QUADWORD/OCTAWORD/PACKED:n
/TASK/TYPE/WORD
Examples
DBG> DEPOSIT L = 10
DBG> DEPOSIT/FLOAT L = 1.1
DBG> DEPOSIT/INSTRUCTION %LINE 100 = 'MOVL R0,R1'
DBG> DEP X = %HEX 10
Parameters
address-expression
Specifies the location to be deposited.
expression
Specifies the value to be deposited. This is usually a constant
(for example, "DEPOSIT X = 2"), but it may be an expression
(e..g., "DEPOSIT X = X + 2").
Qualifiers
The qualifiers on DEPOSIT are used to override the type
information associated with the location. For example, suppose F
is a floating point number. If you do
DBG> DEPOSIT F = 1
then the debugger will convert integer 1 to floating 1.0, and put
the 1.0 into location F. But if you want to put integer 1 into
the location, you need to override the type of F with the /LONG
(integer longword) qualifier:
DBG> DEPOSIT/LONG F = 1
See the individual subtopics for a description of each qualifier.
/ASCIC
Deposit a counted ascii string into the target. This is a string
in which the first byte specifies the length. /AC is also
accepted as an abbreviation for /ASCIC. For example:
DBG> DEPOSIT/AC X = "111"
DBG> EXAM/HEX/LONG X
X: 31313103
/ASCID
The target of the deposit must contain a string descriptor. The
expression on the right-hand side must be a string. The string
is deposited into the address given by the string descriptor. If
the lengths do not match then the string is either truncated on
the right or padded with blanks on the right. /AD is also
accepted.
Example:
DBG> EXAM/QUAD/HEX D
D: 7FFF0000 01E00004
DBG> DEP/AD D = "ABCD"
DBG> EXAM/ASCII:4 7FFF0000
7FFF0000: "ABCD"
DBG> EXAM/AD D
D: "ABCD"
/ASCII:n
Deposits "n" bytes of string into the target location. The
expression on the right-hand-side must be a string. If its
length is not "n" then it will be truncated or padded with blanks
on the right. If "n" is omitted then the debugger uses the
actual length of the data item at the target location.
Example:
DBG> DEPOSIT/ASCII:5 X = "ABCDE"
DBG> EXAM/ASCII:5 X
X: "ABCDE"
/ASCIW
A "asciw string" (a string with a word count at the beginning) is
depositing into the target location. The right-hand-side of the
deposit must specify a string.
/AW is also accepted.
Example:
DBG> DEPOSIT/AW X = "11"
DBG> EXAM/HEX/LONG X
X: 31310002
/ASCIZ
The right-hand-side must be a string. The string is deposited
into the target followed by a zero byte indicating end of string.
/AZ is also accepted.
Example:
DBG> DEP/AZ X = "AAA"
DBG> EXA/LONG/HEX X
X: 00313131
/BYTE
One byte is deposited into the target location.
Example:
DBG> EXA/HEX X
X: 0FFFFFFFF
DBG> DEP/BYTE X = 0
DBG> EXA/HEX X
X: 0FFFFFF00
/D_FLOAT
Specifies that the D_floating type (length 8 bytes) be associated
with the target of the deposit. The right-hand-side is converted
to d_float and deposited into the specified location.
Example:
DBG> DEP/D_ X = 1.1
DBG> EXA/D_ X
X: 1.1000000000000000
/DATE_TIME
The right-hand-side is a string representing a date and time (for
example, "14-Oct-1984 12:00:00"). The date and time is converted
to the quadword representation used by VMS to represent
date-time. This quadword representation is deposited into eight
bytes at the target address.
Example:
DBG> DEP/DATE_TIME X = "14-Oct-1984 12:00:00"
DBG> EXA/DATE_TIME X
X: "14-Oct-1984 12:00:00"
/FLOAT
The right-hand-side is converted to floating point, and the
floating
point value is deposited into the location specified by the
left-hand-side.
Example:
DBG> DEP/F X = 1.1
DBG> EXA/FLOAT X
X: 1.100000
/G_FLOAT
The right-hand-side is converted to floating point (G-format),
and the floating point value is deposited into the location
specified by the left-hand-side.
Example:
DBG> DEP/G_FLOAT X = 1.1
DBG> EXA/G_FLOAT X
X: 1.100000000000000
/H_FLOAT
The right-hand-side is converted to floating point (H-format),
and the floating point value is deposited into the location
specified by the left-hand-side.
Example:
DBG> DEP/H_FLOAT X = 1.1
DBG> EXA/H_FLOAT X
X: 1.10000000000000000000000000000
/INSTRUCTION
The right-hand-side must be a string representing a VAX
instruction. The instruction is deposited into the location
specified by the left hand side.
Example:
DBG> DEP/INS %LINE 100 = 'MOVL 2,B4(R1)'
DBG> E/I %LI 100
%LINE 100: "MOVL 2,B4(R1)"
/LONGWORD
A longword is deposited into the target location.
Example:
DBG> EXA/HEX X
X: 0FFFFFFFF
DBG> DEP/LONG X = 0
DBG> E/HEX X
X: 00000000
/QUADWORD
A quadword (8 bytes) is deposited into the target location.
Example:
DBG> EXA/QUAD/HEX X
X: 0FFFFFFFF FFFFFFFF
DBG> DEP/QUAD X = 0
DBG> EXA/QUAD/HEX X
X: 00000000 00000000
/OCTAWORD
An octaword (16 bytes) is deposited into the target location.
Example:
DBG> E/OCTAW/HEX X
X: 00000000 00000000 00000000 00000000
DBG> DEP/OCTAW X = -1
DBG> EXA/OCTAW/HEX X
X: 0FFFFFFFF FFFFFFFF FFFFFFFF FFFFFFFF
/PACKED:n
The right hand side is converted to a packed decimal
representation (length n nibbles) before doing the deposit. "n"
nibbles ((n+1)/2 bytes) are deposited into the left hand side.
Example:
DBG> DEP/PACKED:5 X = 12345
DBG> EXA/PACKED:5 X
X: 12345
/TASK
The location given by "address-expression" is interpreted as the
address of an Ada task object. The right-hand "expression" is
interpreted as an Ada task value and deposited in the location
specified by "address-expression".
Example:
DBG> EXAMINE VAR
SAMPLE.VAR: 0
DBG> DEPOSIT/TASK VAR = %TASK 2
DBG> EXAMINE/HEX VAR
0016A040
DBG> EXAMINE/TASK VAR
SAMPLE.VAR: %TASK 2
/TYPE=(expression)
Treat the left-hand-side as if it were of the specified type.
(Note - this qualifier is normally only used on EXAMINE, for
example, "EXAMINE/TYPE=(T) 1000". See the help on EXAMINE /TYPE
for more information. The /TYPE qualifier is supplied on DEPOSIT
for completeness.
/WORD
A word (2 bytes) is deposited into the target location.
Example:
DBG> EXA X
X: 0FFFFFFFF
DBG> DEP/WORD X = 0
DBG> EXA X
X: 0FFFF0000