hi,

As well, keyword "volatile" prevents optimizer of skiping re-reading variable when seems that it has not been changed. This keyword notices compiler that variable may be changed it any time not depended on actual code processed.
Here is 2 little examples.
First code:

void main(void)
{
 unsigned char a;
 unsigned int xdata b; 
 while(1)
  {
	a = 5;
	b = a;
  }
}

Second one:

void main(void)
{
 volatile unsigned char a;
 unsigned int xdata b; 
 while(1)
  {
	a = 5;
	b = a;
  }
}

The difference is only that variable "a" is volatile in the second example.
Now try look at actual assembler code generated:
First one:

; a = 5;
MOV      R7,#0x05
; b = a;
MOV      DPTR,#0x0000
CLR      A
MOVX     @DPTR,A
INC      DPTR
MOV      A,#0x05
MOVX     @DPTR,A

And second one:

a = 5;
MOV      0x08,#0x05
; b = a; 
MOV      R7,0x08
MOV      DPTR,#0x0000
CLR      A
MOVX     @DPTR,A
INC      DPTR
MOV      A,R7
MOVX     @DPTR,A

You may see that the first code does not pay attention on actual value of variable "a" when copies it to "b". It just writes number 5. Second code tries re-read value of variable "a" before copy it to "b".

So come back. It seems that in Mark`s code there are some variables which are loaded directly and then have been changed with "not-visible" way. Let say, by work with their pointers, from other part of program in other project etc.

Regards,
Oleg