Learning PTR pointers with dwords

[Konai]

Ok I have used pointers in the past but usually with bytes

Code Select Expand

display_hex proc
; esi has the offset of the (BYTE) to be printed in (HEX).
  xor eax,eax
  mov al,[esi]
  and al,0f0h
  shr al,4
  mov bl,LUT[eax]
  mov [msg],bl
  mov al,[esi]
  and al,0fh
  mov bl,LUT[eax]
  mov [msg+1],bl
  invoke StdOut,ADDR msg
  ret
display_hex endp

In the example above I am using a pointer when I move a byte value into the variable [msg+1]
I understand how this works and what it is doing.

When it comes to dwords though I am somewhat confused.
I am trying to insert into an "array" of dword values. (cnt_array dd 256 dup 0)

What I don't understand is how to do that.

If I do something like ...
dword ptr [count_array+1]
Am I pointing at count_array + 1 byte??? or +1 dword i.e. +4 bytes from the beginning of the array.

Also, when I LUT[eax] to get an offset within that array to return the ascii value of that hex symbol. (LUT is look up table with ascii values of each hex digit in it )
LUT db "0123456789ABCDEF",0

Is there a way to do dword prt LUT[eax+1] ... not really sure if that is a clear question or not, but this question is not as important as the first one.

Ultimately I am trying to get file statistics and count the number of times each byte appears within a file using a pseudo array of dword values to hold the count of each byte that was in the file.

I have tried to make this as clear as possible so please let me know if something I said is confusing or more information is required.

Thank you for your help.

[MichaelW]

To access a DWORD array with an index that advances by 1, you use a scale factor on the index register. The possible values for the scale factor are 1, 2, 4, or 8 (for indexing a BYTE, WORD, DWORD, or QWORD).

Code Select Expand


;==============================================================================
include \masm32\include\masm32rt.inc
;==============================================================================
.data
    cnt_array dd 256 dup(0)
.code
;==============================================================================
;==============================================================================
start:
;==============================================================================
    mov ebx, OFFSET cnt_array
    xor edx, edx
    mov ecx, 256
  @@:
    mov [ebx+edx*4], edx
    inc edx
    dec ecx
    jnz @B

    xor edx, edx
    mov ecx, 256
  @@:
    mov eax, [ebx+edx*4]
    pushad
    printf("%d\t", eax)
    popad
    inc edx
    dec ecx
    jnz @B
    printf("\n\n")

    inkey
    exit
;==============================================================================
end start


[Konai]

Ok, the scaling factor is what I was missing. Thank you very much for your help!

[MichaelW]

I'm not sure about your second question. You could do a DWORD LUT like this:

LUT dd "0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"

But I see no need for a table of ASCII character codes for counting the occurrences of the BYTE values 0-255.

[FORTRANS]

Hi,

   If you want to count characters, just use the character
shifted to the counter size to access the counter array.

Code Select Expand


Counts  DD      256 DUP ( 0 )

...

        XOR     EAX,EAX ; Zero entire register.
        MOV     AL,Char ; Get your character.
        SHL     EAX,2   ; Byte count to DWORD pointer.
        INC     [Counts+EAX]


HTH,

Steve N.