[go: up one dir, main page]
Scribd
Upload
7 views8 pages

Vars

The document explains the concept of variables in the Emu8086 compiler, detailing the syntax for declaring BYTE and WORD variables, as well as how to use the MOV instruction to manipulate them. It also covers arrays, including their definition, access methods, and the use of the DUP operator for creating large arrays. Additionally, it describes how to obtain the address of a variable using LEA and OFFSET instructions, and provides guidance on viewing and editing variables during program execution.

Uploaded by

amanyhassan557
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
7 views8 pages

Vars

The document explains the concept of variables in the Emu8086 compiler, detailing the syntax for declaring BYTE and WORD variables, as well as how to use the MOV instruction to manipulate them. It also covers arrays, including their definition, access methods, and the use of the DUP operator for creating large arrays. Additionally, it describes how to obtain the address of a variable using LEA and OFFSET instructions, and provides guidance on viewing and editing variables during program execution.

Uploaded by

amanyhassan557
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 8

Variables

Variable is a memory location. For a programmer it is much


easier to have some value be kept in a variable named "var1"
than at the address 5A73:235B, especially when you have 10
or more variables.

Emu8086 compiler supports two types of


variables: BYTE and WORD.

Syntax for a variable declaration:

name DB value

name DW value

DB - stays for Define Byte.


DW - stays for Define Word.

name - can be any letter or digit combination, though it should


start with a letter. It's possible to declare unnamed variables by
not specifying the name (this variable will have an address but
no name).

value - can be any numeric value in any supported numbering


system (hexadecimal, binary, or decimal), or "?" symbol for
variables that are not initialized.

As you probably know, MOV instruction is used to copy


values from source to destination.

Let's see an example with MOV instruction:

ORG 100h

MOV AL, var1


MOV BX, var2

RET

VAR1 DB 7
var2 DW 1234h
Compiler is not case sensitive, so "VAR1" and "var1" refer to
the same variable.

The offset of VAR1 is 0108h.

The offset of var2 is 0109h, this variable is a WORD so it


occupies 2 BYTES. It is assumed that low byte is stored at
lower address, so 34h is located before 12h.

You can see that there are some other instructions after
the RET instruction, this happens because disassembler has
no idea about where the data starts, it just processes the
values in memory, and it understands them as valid 8086
instructions.

ORG 100h is a compiler directive (it says to compiler how to


handle the source code). This directive is very important
when you work with variables. It says to compiler that the
executable file will be loaded at the offset of 100h (256
bytes), so compiler should calculate the correct address for
all variables when it replaces the variable names with
their offsets. Directives are never converted to any
real machine code.

Why executable file is loaded at offset of 100h? The


operating system keeps some data about the program in the
first 256 bytes of the CS (code segment), such as command
line parameters and etc.

Arrays
Arrays can be seen as chains of variables. A text string is an
example of a byte array, each character is presented as an
ASCII code value (0..255).
Here are some array definition examples:

a DB 48h, 65h, 6Ch, 6Ch, 6Fh, 00h


b DB 'Hello', 0

"b" is an exact copy of the "a" array, when compiler sees a


string inside quotes it automatically converts it to set of bytes.
This chart shows a part of the memory where these arrays
are declared:

You can access the value of any element in array using square
brackets, for example:

MOV AL, a[3]

You can also use any of the memory index registers BX, SI,
DI, BP, for example:

MOV SI, 3
MOV AL, a[SI]

If you need to declare a large array you can


use DUP operator.
The syntax for DUP:

number DUP ( value(s) )

number - number of duplicate to make (any constant value).


value - expression that DUP will duplicate.

for example:
c DB 5 DUP(9)
is an alternative way of declaring:
c DB 9, 9, 9, 9, 9

one more example:


d DB 5 DUP(1, 2)

is an alternative way of declaring:


d DB 1, 2, 1, 2, 1, 2, 1, 2, 1, 2

Getting the Address of a Variable


There is LEA (Load Effective Address) instruction and
alternative OFFSET operator. Both OFFSET and LEA can be
used to get the offset address of the variable.

LEA is more powerful because it also allows you to get the


address of an indexed variable. Getting the address of the
variable can be very useful in some situations, for example
when you need to pass parameters to a procedure.

Reminder:
In order to say the compiler about data type,
these prefixes should be used:

BYTE PTR - for byte.


WORD PTR - for word (two bytes).

For example:
BYTE PTR [BX] ; byte access.
or
WORD PTR [BX] ; word access.
MicroAsm supports shorter prefixes as well:

b. - for BYTE PTR


w. - for WORD PTR

sometimes compiler can calculate the data type automatically, but you may not and should not rely on that
when one of the operands is an immediate value.
Here is first example:

ORG 100h

MOV AL, VAR1 ; check value of VAR1 by moving it to


AL.
LEA BX, VAR1 ; get address of VAR1 in BX.
MOV BYTE PTR [BX], 44h ; modify the contents of VAR1.
MOV AL, VAR1 ; check value of VAR1 by moving it to
AL.

RET

VAR1 DB 22h

END

Here is another example, that uses OFFSET instead of LEA:

ORG 100h

MOV AL, VAR1 ; check value of VAR1 by moving it to


AL.
MOV BX, OFFSET VAR1 ; get address of VAR1 in BX.
MOV BYTE PTR [BX], 44h ; modify the contents of VAR1.
MOV AL, VAR1 ; check value of VAR1 by moving it to
AL.

RET

VAR1 DB 22h

END

Both examples have the same functionality.

These lines:
LEA BX, VAR1
MOV BX, OFFSET VAR1
are even compiled into the same machine code: MOV BX, num
num is a 16 bit value of the variable offset.

Please note that only these registers can be used inside


square brackets (as memory pointers): BX, SI, DI, BP!
You can view variables while your program executes by
selecting "Variables" from the "View" menu of emulator.

To view arrays you should click on a variable and


set Elements property to array size. In assembly language
there are not strict data types, so any variable can be
presented as an array.

Variable can be viewed in any numbering system:

• HEX - hexadecimal (base 16).


• BIN - binary (base 2).
• OCT - octal (base 8).
• SIGNED - signed decimal (base 10).
• UNSIGNED - unsigned decimal (base 10).
• CHAR - ASCII char code (there are 256 symbols, some
symbols are invisible).

You can edit a variable's value when your program is running,


simply double click it, or select it and click Edit button.

It is possible to enter numbers in any system, hexadecimal


numbers should have "h" suffix, binary "b" suffix, octal "o"
suffix, decimal numbers require no suffix. String can be
entered this way:
'hello world', 0

(this string is zero terminated).

Arrays may be entered this way:

1, 2, 3, 4, 5

(the array can be array of bytes or words, it depends


whether BYTE or WORD is selected for edited variable).

Expressions are automatically converted, for example:


when this expression is entered:

5+2

it will be converted to 7 etc...

You might also like