ASM Community

Look at the code.
 m2m caW,lParam[0] ;client area width
 m2m caH,lParam[2] ;client area height

To understand it fully in need to have a clear picture of what
actually are arguments in stdcall procs, locals, stack, and stack frame.
In such times I really hate R.Hyde - he might have wrote good,
big and detailed articles on such topics, but he prefered his HLA when
proceeded to Win32 ASM.

I'm not going now in detail of stack framing, only basic information.
When in a proc like:

WndProc proc hWnd:DWORD,uMsg:DWORD,wParam:DWORD,lParam:DWORD

...
and then you addressing to any of the argument
like mov eax,hWnd
or    .IF uMsg==WM_SIZE (really: cmp uMsg,5)

You are in real code addressing to data throu ebp as a pointer.

At the begining of such procs there is stack framing routine:
;upon entry in stack return address and followed it arguments
       puch ebp ;now in stack old ebp, ret address,arg
       mov ebp,esp ;it's for using ebp as pointer for memory in stack
       sub esp,number of bytes needed for locals
....
after that you may see that
data in  = old ebp
data in  = return address
data in  = first argument (the same is [8]
as you can see step is 4: ,[4],[8]
because all this data has DWORD size (4 bytes)
So now you probably can see that
 mov eax,hWnd is really mov eax,dword ptr [8]
 sub eax,uMsg   is really sub eax,dword ptr  ;
 if wParam == WM_SIZE is really cmp dword ptr [10h],5
 or eax,lParam is really or eax,dword ptr [14h]

So what is lParam[2]? it's [14h]+2 which is [16h]

Now let's have a look at the code:

 m2m caW,lParam[0] ;client area width
 m2m caH,lParam[2] ;client area height

 invoke GetWindowRect,hStatus,ADDR Rct
 mov eax, Rct.bottom
 sub eax,Rct.top
 sub caH,eax
 invoke MoveWindow,hStatus,0,caH,caW,caH,TRUE

It is for repositioning status bar.
m2m is macro and means
 push memsource
 pop  memdest
caW and caH are local varibles and also addressed with help of ebp but
with minus offset 'cause they are between old esp and new esp
after substruction from esp number of bytes we need for local.
Because frame rutine put old esp to ebp (mov ebp,esp) and stack is growing
down (all new data with pushes go to less adresses then previous) memory
for locals are always in region between ebp (wich has bigger address) and new esp 
(wich has less address). It preserves locals from owewriting by stack operations
and allow address to them using ebp as a pointer so
 = address of the first local dword
 = address of the second and so on.

so
m2m caW,lParam[0] ;client area width
 m2m caH,lParam[2] ;client area height
might for example means
 push [14]
 pop   
 push [16]
 pop   [-8]

Enough for now. Hope it help at least understand
 m2m caW,lParam[0] ;client area width
 m2m caH,lParam[2] ;client area height
is 4 stack operation with memory addressed by ebp.

Actually Steve (the author) found not bad way to address to width and height partts
in lParam. Instead of shifing and anding to extract low and high word from DWORD lParam
he just shift address by 2 so that low word of lParam gets in low word of one local
variable and high word of lParam gets in LOW WORD of the other local variable.
Good trick, Steve :)

Let's now count size and clocks for this part of code and try to do it faster and shorter.

 push [14]
 pop   
 push [16]
 pop   [-8] 

Push memory 2 clocks, size with this addr. mode - 3 bytes
Pop memoty 3 clocks,size with this addr mode - 3 bytes
Altogether 10 clocks , 12 bytes.

Second part
 mov eax, Rct.bottom	;1 clock ,3 bytes
 sub eax,Rct.top		;2 clocks,3 bytes
 sub caH,eax	                ;3 clocks,3 bytes
;6 clocks, 9 bytes to culculate
invoke MoveWindow,hStatus,0,caH