;@ WindowProc:
        virtual at esp+8
                .wmsg  rd 1
        end virtual
    

;
; WinMain (hInstance, hPrevInstance, pszCmdLine, iCmdShow)
;
invoke GetModuleHandle, 0
mov [hInstance], eax
;
; hPrevInstance is never needed in Win32 (it was needed in Win16)
;
invoke GetCommandLineA
mov [pszCmdLine], eax
;
; iCmdShow is needed in some rare cases. It is a parameter
; usually passed to ShowWindow to display main application
; window for the first time. Just pass SW_NORMAL for now.
; If you really need this parameter -- use GetStartupInfo API to get it.
;
    

HWND equ dd
HFONT equ dd
PRECT equ dd
CHARS equ rb

...

virtual at 0
OBJECT1:
     .pRect1 PRECT ?
     .hFont  HFONT ?
     .path   CHARS 256
   .size = $
end virtual
;
; at this point the OBJECT1 can be used as a structure.
; you can get it size by using OBJECT1.size and access its members by using
; the proper expression with a member name:
;
mov esi, ... ; <-- load address of a structure into a register
mov eax, [esi + OBJECT1.hFont]   ; Load the font handle
;
; or use it in API calls without loading it into a register
;
invoke GetClientRect, [hWnd], [esi + OBJECT1.pRect]
;
    

the type of the element in a structure
can be only one of types defined by FASM, like DD,DW,DB, etc.

struc HWND [args] { common . dd args }
struc HFONT [args] { common . dd args }
struc PRECT [args] { common . dd args }
struc CHARS [args] { common . rb args }

struct OBJECT
        pRect1 PRECT ? 
        hFont  HFONT ? 
        path   CHARS 256 
ends    

Shouldn't the size be ".size = $ - OBJECT1"

Anyway, using structures it bad or good?

And what exactly do you mean by object variables?

;a structure with defined fields:
obj1 OBJECT 0x401234,2,'Hello, world!'
;a structure with undefined fields
obj2 OBJECT    

How are object variables different from labels, they both point to a chunk of memory, no?

struct OBJECT 
        pRect1 PRECT ?  
        hFont  HFONT ?  
        path   CHARS 256  
ends    

What do you gain by this? If I understand correctly, .wmsg becomes a synonym for ESP+8. Why not just do a .wmsg equ ESP+8?

WindowProc:
 virtual at esp+8
 .wmsg  rd 1
 .wp    rd 1
 end virtual    

virtual at ebp
     w1     rq 1
     w2     rq 1
     w3     rq 1
     w4     rq 1
end virtual

virtual at esi
     x1     rq 1
     x2     rq 1
     x3     rq 1
     x4     rq 1
end virtual

lea     edi,[w3]
fld     [x3]    

00401503 |. 8D7D 10 LEA EDI,[EBP+10]
00401506 |. DD46 10 FLD [QWORD DS:ESI+10]

Code:

;@ WindowProc: 
        virtual at esp+8 
                .wmsg  rd 1 
        end virtual    

What do you gain by this? If I understand correctly, .wmsg becomes a synonym for ESP+8. Why not just do a .wmsg equ ESP+8?

label .wmsg dword at esp+8    

BYTES equ rb

...

virtual at 0
OBJECT2:
  .chunk1 BYTES OBJECT1.size
  .chunk2 BYTES OBJECT1.size
  .chunk3 BYTES OBJECT1.size
end virtual
    

    ;
   ; EBX points to OBJECT2
     ;
   lea     esi, [ebx + OBJECT2.chunk3]
 mov     eax, [esi + OBJECT1.hFont]
    

 mov     eax, dword [ebx + OBJECT1.hFont + OBJECT2.chunk3]
    

  mov     eax, this.chunk3.hFont
      call    this.OnCreate (loc.vectCells, loc.uiNumCells, glb.hHeap, L"HELLO")
    

The new IDE I am writing will have easier way of coding, like:

Code:

 mov     eax, this.chunk3.hFont
      call    this.OnCreate (loc.vectCells, loc.uiNumCells, glb.hHeap, L"HELLO")
    

And the code generator runs through this script doing stuff, like
- putting UNICODE text "HELLO" into data section,
- calling virtual methods,
- passing local and global variables,
- etc.

proc !IsLetter uses edx, Character

  ;
  ; Making all the characters lowercase makes evaulation
  ; easier
  ;
  stdcall      !ToLowercase, [Character]

  mov          ecx, 26
  mov          edx, 97
SearchCharacters:
  cmp          eax, edx
  je           CharacterFound
  inc          edx
  loop         SearchCharacters

  ;
  ; If the [Character] is not a letter, return 0
  ;
  mov          eax, 0
  ret

CharacterFound:
  mov          eax, 1

  ret
endp    

proc !IsNumber uses edx, Character

  mov          ecx, 10
  mov          edx, 48
SearchCharacters:
  cmp          [Character], edx
  je           CharacterFound
  inc          edx
  loop         SearchCharacters

  ;
  ; If the [Character] is not a number, return 0
  ;
  mov          eax, 0
  ret

CharacterFound:
  mov          eax, 1

  ret
endp    

proc !IsAlphanumeric uses edx, Character

  stdcall      !IsLetter, [Character]
  mov          edx, eax
  stdcall      !IsNumber, [Character]
  or           edx, eax
  cmp          edx, 1
  je           CharacterFound
  mov          eax, 0
  ret

CharacterFound:
  mov          eax, 1

  ret
endp    

proc1:
       ...
 jmp     proc2.LABEL1
        ...
 ret

proc2:
       ...
.LABEL1:
 ...
 ret