Comparing C++ Char's in Assembly, and working with arrays.

[Vintage1983]

I am in my first semester of assembly on the intel 86x processor. Basicly I have been working on this problem and another for about two weeks and my book and net references haven't been able to help me out.

I have two basic problems I am dealing with right now. I am basicly traversing a array of strings (multi-dimensional array) and ordering the strings based on alpha-order. The array is made in C++ and being passed to my Assembly code in a .asm file. My .asm file will then sort the array. My first problem is I am having trouble understanding how to traverse a array while parameters are being passed after the array. To me it doesn't make sense that the reference to the array would be [ebp+8] and we normally would traverse the array by incrementing [ebp] but yet we can get the second parameter @ [ebp+12]. I've read about using OFFSET but i don't fully understand it. I can imagine how this could be used but I can't seem to figure it out.

My second issue is how to deal with the char data once I've brought it into my proc, I can't seem to find very much information related to Assembly and chars (assuming because they become ascii value?). Is a greater char (ex:T) always going to have a greater ascii value than a lesser char (ex: A).

This is my proc at the moment, I'm not so worried about traversing the array once I understand how to get the initial values as I have worked out the logic of this all before hand, just mostly looking for a decent example or clear instruction on how it works.


.386

.model flat

public _Sort

.data

zero word 0
switch word 0
array_length dword ?
found_length dword 0
char_position dword 0
bytes_per_line dword ?
holdover dword ?
POS1 dword ?
POS2 dword ?
array_addy dword ?

.code

_Sort proc

push ebp
mov ebp, esp
mov eax, [ebp+8]
mov array_addy, eax
mov eax, [ebp+12]
mov array_length, eax
mov eax, [ebp+16]
mov bytes_per_line, eax

mov eax, array_length
cmp eax, 0 ;jump if array has length of 0
jnae EndTRow

mov ebx, found_length
inc ebx ;add 1 to found_length's sum
cmp ebx, eax ;jump if at last row
ja EndTrow

Tcolumns:
mov eax, char_position
mov ebx, bytes_per_line
cmp eax, ebx
jnb H1

mov ebx, OFFSET array_addy

add ebx, (found_length+1) ;getting second string
mov ecx, char_position
mov eax, [ebx + ecx]
push eax


H1:
; mov eax, found_length ;increasing found_length
; inc eax
; mov found_length, eax

; mov ebx, [ebp+8]
; mov ebx, OFFSET eax
; add ebx, (bytes_per_line*found_length)
; mov esi, 0
; mov ax, 0 ;to hold char1
; mox dx, 0 ;to hold char2




EndTrow:
pop ebp
ret
_Sort endp

end



This is the C++ code I have to work with...


extern "C" int Sort (char [] [20], int, int);

...

main...some code...

Sort (Strings, 10, 20);
cout << "Sorted Strings are" << endl;
for (i = 0; i < 10; i++)
cout << '\t' << Strings [i] << endl;


Any help is much appreciated, I have worn myself out playing with this stuff.

[kahlinor]

I have two basic problems I am dealing with right now. I am basicly traversing a array of strings (multi-dimensional array) and ordering the strings based on alpha-order.

My assumption is that you have an array of string pointers. On a 32 bit machine, each reference is 4 bytes long.

My first problem is I am having trouble understanding how to traverse a array while parameters are being passed after the array.

On a single dimension array, you traverse it by adding the element size to your current pointer. For an array of string pointers, this would be 4.


To me it doesn't make sense that the reference to the array would be [ebp+8] and we normally would traverse the array by incrementing [ebp]

No. You don't increment [EBP]. If [EBP+8] is the address of the array, then just move it into a base register (eg: ebx is good choice).

mov ebx, [EBP+8] ; ebx = starting address

From here, [ebx] is the first element. To get the next element, you add 4 to ebx. If you want to get the next element without changing the index;

eg:

mov ebx, [ebp+8]; ebx = address of array
mov eax, [ebx] ; eax = address of 1st string
mov ecx, [ebx+4] ; ecx = address of 2nd string in array
; call some function to compare strings by address
add ebx, 4 ; point ebx to the next element in the array
...

; if you want to use a base register and an index register:
mov eax, 0 ; eax is index register
mov ebx, [ebp+8] ; ebx is base register
mov ecx, [ebx+eax*4]; ecx = element # in eax



Using a base + index register allows you to use a method similar to what you would use in C.


but yet we can get the second parameter @ [ebp+12]. I've read about using OFFSET but i don't fully understand it. I can imagine how this could be used but I can't seem to figure it out.

I'm not too keen on MASM syntax, but I think OFFSET is for getting the address of automatic variables (variables declared as local in the proc). It won't help you here.

[kahlinor]

Anyway, just to give you an idea, here is some HLA code that displays an array of strings. As an exercise, translate it to your assembly syntax and it will give you something to work on. Remember, in HLA, source and destination operands are reversed!
So
mov (eax, ebx); in HLA is the same as

mov ebx, eax in your assembler.


program strarray;

#includeonce ("stdlib.hhf")

?@nodisplay := true;
?@noalignstack := true;

static
// form an array of strings
strs :string[] :=
[ "string one",
"string two",
"string three",
"string four" ];

procedure showStrs; @noframe;
begin showStrs;
push (ebp);
mov (esp, ebp);

mov ([ebp+12], ebx); // get address of array in ebx
mov ([ebp+8], ecx); // get number of elements in ecx

// for (i=0; i < ecx; i++)
xor (eax, eax); // eax is our index = 'i'
printStrs:
cmp (eax, ecx);
je done;
mov ([ebx+eax*4], edx);
pushd (edx);
call stdout.puts;
call stdout.newln;
inc (eax);
jmp printStrs;
done:

pop (ebp);
ret();
end showStrs;


begin strarray;

pushd (&strs); // push address of array
pushd (@elements (strs)); // push number of array elements
call showStrs;
add (8, esp); // balance the stack!

end strarray;