Delphi 6 to Delphi 2007 - delphi

Question

Just hitting various bricks walls with years worth of code updating, but the current one i cant seem to convert is this
Function Pack (Var Source, Dest; Count : Word) : Word; Assembler;
Asm
Push DS
Mov BX, Count { BX = Count }
Mov AX, Word Ptr Dest
Mov DI, AX
Mov AX, Word Ptr Dest+2 `1`
Mov ES, AX { ES:DI - Dest }
Mov AX, Word Ptr Source
Mov SI, AX
Mov AX, Word Ptr Source+2
Mov DS, AX { DS:SI - Source }
Xor DX, DX { Packed size }
CLD
#Cycle:
Or BX, BX
JZ #End { Done }
LODSB
Mov CX, BX
Cmp CX, 100H
JC #1
Mov CX, 0FFH
#1:
Mov AH, CL
Push ES
Push DI { Save ES:DI before scan }
Push SI
Pop DI
Push DS
Pop ES { ES:DI = DS:SI for scan }
RepE ScaSB
Dec DI
Push DI
Pop SI
Push ES
Pop DS { DS:SI = ES:DI for next }
Pop DI
Pop ES { Restore ES:DI after scan }
Sub AH, CL
Mov CL, AH { CX = repeat count }
Cmp AH, 3
JNC #3 { Repeat count >= 3 }
Cmp AL, RP
JNE #2 { Not a RepeatPrefix byte }
STOSW { Save RP, repeat count < 3 }
Sub BX, CX { Actually count in source }
Add DX, 2 { Actually packed size }
Jmp #Cycle
#2:
Sub BX, CX { Actually count in source }
Add DX, CX { Actually packed size }
Rep STOSB { Save bytes }
Jmp #Cycle
#3:
Sub BX, CX { Actually count in source }
Add DX, 3 { Actually packed size }
Mov CL, AL
Mov AL, RP
STOSW { Save RP, repeat count < 3 }
Mov AL, CL
STOSB { Save repeating byte }
Jmp #Cycle
#End:
Pop DS
Mov AX, DX { Return packed size }
End;
Function UnPack (Var Source, Dest; Count : Word) : Word; Assembler;
Asm
Push DS
Mov BX, Count { BX = Count }
Mov AX, Word Ptr Dest
Mov DI, AX
Mov AX, Word Ptr Dest+2
Mov ES, AX { ES:DI - Dest }
Mov AX, Word Ptr Source
Mov SI, AX
Mov AX, Word Ptr Source+2
Mov DS, AX { DS:SI - Source }
Xor DX, DX { Packed size }
Xor AH, AH
CLD
#Cycle:
Or BX, BX
JZ #End { Done }
LODSB
Dec BX
Cmp AL, RP
JE #1
STOSB
Inc DX
Jmp #Cycle
#1:
LODSB
Mov CX, AX
Add DX, CX
Dec BX
Cmp AL, 3
JNC #2
Mov AL, RP
Rep STOSB
Jmp #Cycle
#2:
LODSB
Dec BX
Rep STOSB
Jmp #Cycle
#End:
Pop DS
Mov AX, DX
End;
[DCC Error] Packer.pas(20): E2107 Operand size mismatch " Mov AX, Word Ptr Dest"
[DCC Error] Packer.pas(22): E2105 Inline assembler syntax error" Mov AX, Word Ptr Dest+2 `1`"
[DCC Error] Packer.pas(24): E2107 Operand size mismatch "Mov AX, Word Ptr Source"
[DCC Error] Packer.pas(87): E2107 Operand size mismatch" Mov AX, Word Ptr Dest"
[DCC Error] Packer.pas(91): E2107 Operand size mismatch " Mov AX, Word Ptr Source"
I spent far to many years on d6, what am i doing wrong?

Answer 1

As a general rule, inline assembly code that compiles in Delphi 6 will compile in later versions too. So no porting should be needed. Indeed, when you attempt to compile this code in Delphi 6, it fails with exactly the same errors as you report from D2007.
You also mention in the comments that you have not been compiling the code in Delphi 6, but have rather been using a compiled .dcu file. Which makes more sense, given that the code in the question does not compile in Delphi 6.
The reason the code does not compile in Delphi 6 is that it is not 32 bit code. It seems to me to be 16 bit code.
Reading between the lines I suspect that the code you have dates from long ago, in the 16 bit age. When the code was moved to 32 bit someone ported the code but left you a .dcu file rather than the source.
You are thus in a pickle. Without knowing what's in this .dcu file what are you to do? Are you even sure that the .dcu file does the same as this 16 bit assembly code? Do you have a functional specification for these functions?
In an ideal world you would know what these functions do and would be able to port them to Pascal. Then you would no longer be tied to assembler code.
If you don't know what these functions do you should find out. I would not trust that your 16 bit assembler matches what your .dcu file does. I would disassemble the .dcu file and port that to Pascal.
If even that's too hard, then the expedient approach is to use Delphi 6 to compile the .dcu file into a DLL. Then you can call these functions from your ported D20007 program. This will work but it leaves you no closer to knowing what your code does.

Answer 2

Yes it is 16 bit register.
Just an idea, maybe declare in your variables example AX as word and AH, AL as byte but you will need to rename them.
example...
Function Example (Var Source, Dest; Count : Word) : Word; Assembler;
var
iAX, iBX, iCX, iDX, iBP, iSI, iDI, iSP: Word;
iAH, iAL, iBH, iBL, iCH, iCL, iDH, iDL : Byte
Asm
Push DS
Mov iBX, Count
Mov iAX, Word Ptr Dest
Mov iDI, iAX
Mov iAX, Word Ptr Dest+2
Mov iES, iAX
.......
P.s
You might have to change "Push DS" and "POP DS" to "PUSH ESI" and "POP ESI"