The 'pk' macro can be pretty useful. It can either make the code more readable in some cases, and add some optimizations for situations like:

Code:

mov bh, 5
mov bl, 1
mov ax, 2    

Which, written using the 'pk' macro pk mov bh:5, bl:1, ax:2 becomes:

Code:

mov bx, 0x0501  ; bh is 5 and bl is 1
mov ax, 2    

packs the constant values after the ':' into corresponding registers; everything is processed from left to right, so if you define ah:5 and then eax:2, the value in ah (5) will be completely replaced.

NOTE: this macro packs ONLY constants (immediate values).

Another example:

Code:

pk mov ah:5, eax:2    

will generate

Code:

mov eax, 2    

because eax:2 was encountered after ah:5, and it completely replaced it, since eax occupies the entire register, so it is, in fact, mov eax, 0x00000002, which completely sets ah to 0!

Please be careful when using these instructions (in fact, those that modify flags, e.g: add, sub, xor...). They DO NOT generate the same flags. Always try to imagine what will become after these instructions, and do the flag operations accordingly.

Another example:

Code:

pk and cx:1125h, eax:2, ch:3    

This produces the actual:

Code:

and cx, 0x0325
and eax, 2    

ch:3 replaces the 0x11 in cx's upper byte, because it is on the right, which means it is processed after cx... eax should be obvious

and cx, 0x0325 is used here before and eax, 2 because the counter (cl,ch,cx,ecx) register was found before the accumulator (al,ah,ax,eax).

It's important to note this is only a macro, not something magical, and as such you should not overuse it, especially in some circumstances where it generates improper or poor code. And watch out for the flags!

macro pk [def]
{
 common
  ; list holds the ordered register bases, which are in fact
  ; symbolic constants representing the size mask
  ;
  ; the SIZE MASK is the mask of the compiled reg
  ; ex: FFFF means 16-bit register, FF00 means high-part 8-bit reg (ah,bh,ch,dh), etc...
  ;
  define list +  ; dummy value to start

  ; base is register type (accumulator, counter, etc...)
  ; the SIZE MASK is the second symbol
  ; third symbol is shift left value (i.e ch has shift=8 )
  ;
  ; these are stored temporary in 't' symbolic constant
  ; 't' also serves for other purposes (like error checking)
  define t

  ;
  ; each base name (eg: ax for accumulator, si for source index) has 2 type of prefixes
  ; if prefix is '_' then the specified symbolic constant contains the SIZE MASK
  ; if prefix is 'c' it means it's the 'immediate' or 'constant' value for the register
  ;
  ; eg: _ax is the SIZE MASK for accumulator
  ;     cax is the immediate value for accumulator
  ;
  ;     if _ax = $FFFFFFFF
  ;       mov eax, cax
  ;     else if _ax = $FFFF
  ;       mov ax, cax
  ;     ...
  ;
  ; or something like that 
  ;
  irp r, ax,bx,cx,dx,si,di,bp,sp \{ define _\#r \}  ; null-out all the SIZE MASKS

  match instr p, def \{
   irp parm, p \\{ match reg:v, parm \\\{

    irp r, ax,bx,cx,dx,si,di,bp,sp \\\\{
     match =e\\\\#r, reg \\\\\{ define t r FFFFFFFF 0 \\\\\}
     match =r, reg \\\\\{ define t r FFFF 0 \\\\\} \\\\}

    irp r, a,b,c,d \\\\{
     match =r\\\\#h, reg \\\\\{ define t r\\\\\#x FF 8 \\\\\}
     match =r\\\\#l, reg \\\\\{ define t r\\\\\#x FF 0 \\\\\} \\\\}

    match , t \\\\{
     @err ; invalid register
    \\\\}

    match base mask shift, t \\\\{
     restore t  ; revert back to empty definition

     if (~ v eqtype 0) | (v > $\\\\#mask)
      err ; invalid immediate operand
     end if


     match , _\\\\#base \\\\\{
      match old, list \\\\\\{
       restore list
       define list old,base  ; append it to the list
      \\\\\\}

      restore _\\\\\#base
      define _\\\\\#base 0  ; starting number (size mask)
      define c\\\\\#base 0
     \\\\\}

     match size, _\\\\#base \\\\\{
      restore _\\\\\#base
      define _\\\\\#base (size) or ($\\\\\#mask shl shift)  ; combine it with the mask
     \\\\\}

     match val, c\\\\#base \\\\\{
      restore c\\\\\#base

      ; now calculate the immediate
      ; first clear the bits in val, within our current mask
      ; then 'or' it with the new value to yield the result
      define c\\\\\#base (val) and not ($\\\\\#mask shl shift)  or  ((v) shl shift)
     \\\\\}

    \\\\} define t + \\\}    ; just a signal

    match , t \\\{
     @err ; invalid arguments
    \\\}
    restore t                ; remove the signal
   \\}

   ; iterate through the list and encode the specified instructions
   ; each element in the list is the name of a symbolic constant (base name)
   ; well, in fact it's the name of the symbolic constant without '_' prefix
   ; anyway, we also need it for constant value (with a 'c' prefix)
   ; '_' prefix means the SIZE MASK for the specified base register

   restore t  ; remove the empty definition
   define t + ; just a signal to indicate our  match instr p, def  did work

   match +=,regs, list \\{   ; list began with a dummy '+' value, so ignore it and the comma
    restore list

    irp r, regs \\\{

     if _\\\#r = $FFFFFFFF   ; ex: eax
       instr e\\\#r, c\\\#r
     else if _\\\#r = $FFFF  ; ex: ax
       instr r, c\\\#r
     else if _\\\#r = $FF00  ; ex: ah
       irp i, a,b,c,d \\\\{ match =i\\\\#x, r \\\\\{
        instr i\\\\\#h, c\\\\\#r shr 8
       \\\\\} \\\\}
     else
       irp i, a,b,c,d \\\\{ match =i\\\\#x, r \\\\\{
        instr i\\\\\#l, c\\\\\#r
       \\\\\} \\\\}
     end if

     restore _\\\#r,c\\\#r ; clean up
    \\\}
   \\}
  \}

  ; see if pk has invalid arguments (if first match was false)
  ; use t as an arbitrary variable to signal if match was processed
  match , t \{
   @err ; invalid use of instruction argument
  \}

  ; cleanup
  restore t
}    

mov bx, 0x0501 ; bh is 5 and bl is 1

if 0
err
end if    

a=1
if a=0
  err
end if