pragmas.h

小型游戏引擎

        modify exact [eax edx]\

long divscale27(long i1, long i2);
#pragma aux divscale27 =\
        "mov edx, eax",\
        "sar edx, 5",\
        "shl eax, 27",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale28(long i1, long i2);
#pragma aux divscale28 =\
        "mov edx, eax",\
        "sar edx, 4",\
        "shl eax, 28",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale29(long i1, long i2);
#pragma aux divscale29 =\
        "mov edx, eax",\
        "sar edx, 3",\
        "shl eax, 29",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale30(long i1, long i2);
#pragma aux divscale30 =\
        "mov edx, eax",\
        "sar edx, 2",\
        "shl eax, 30",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale31(long i1, long i2);
#pragma aux divscale31 =\
        "mov edx, eax",\
        "sar edx, 1",\
        "shl eax, 31",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale32(long i1, long i2);
#pragma aux divscale32 =\
        "xor eax, eax",\
        "idiv ebx",\
        parm nomemory [edx][ebx]\
        modify exact [eax edx]\

/* !!! move these into ves.h?  --ryan. */
#ifdef PLATFORM_DOS

void int5(void);
#pragma aux int5 =\
        "int 0x5",\

int setupmouse(void);
#pragma aux setupmouse =\
        "mov ax, 0",\
        "int 33h",\
        "and eax, 0x0000ffff",\
        modify exact [eax]\

void readmousexy(short *x, short *y);
#pragma aux readmousexy =\
        "mov ax, 11d",\
        "int 33h",\
        "mov [esi], cx",\
        "mov [edi], dx",\
        parm [esi][edi]\
        modify exact [eax ebx ecx edx]\

void readmousebstatus(short *buttons);
#pragma aux readmousebstatus =\
        "mov ax, 5d",\
        "int 33h",\
        "mov [esi], ax",\
        parm [esi]\
        modify exact [eax ebx ecx edx]\

unsigned char readpixel(long offset);
#pragma aux readpixel =\
        "mov al, byte ptr [edi]",\
        parm nomemory [edi]\
        modify exact [eax]\

void drawpixel(long offset, unsigned char p);
#pragma aux drawpixel =\
        "mov byte ptr [edi], al",\
        parm [edi][eax]\
        modify exact \

void drawpixels(long offset, unsigned short p);
#pragma aux drawpixels =\
        "mov word ptr [edi], ax",\
        parm [edi][eax]\
        modify exact \

void drawpixelses(long offset, unsigned long p);
#pragma aux drawpixelses =\
        "mov dword ptr [edi], eax",\
        parm [edi][eax]\
        modify exact \

#endif


void clearbuf(void *buf, long i2, long i3);
#pragma aux clearbuf =\
        "rep stosd",\
        parm [edi][ecx][eax]\
        modify exact [edi ecx]\

void clearbufbyte(void *buf, long i2, long i3);
#pragma aux clearbufbyte =\
        "cmp ecx, 4",\
        "jae longcopy",\
        "test cl, 1",\
        "jz preskip",\
        "stosb",\
        "preskip: shr ecx, 1",\
        "rep stosw",\
        "jmp endit",\
        "longcopy: test edi, 1",\
        "jz skip1",\
        "stosb",\
        "dec ecx",\
        "skip1: test edi, 2",\
        "jz skip2",\
        "stosw",\
        "sub ecx, 2",\
        "skip2: mov ebx, ecx",\
        "shr ecx, 2",\
        "rep stosd",\
        "test bl, 2",\
        "jz skip3",\
        "stosw",\
        "skip3: test bl, 1",\
        "jz endit",\
        "stosb",\
        "endit:",\
        parm [edi][ecx][eax]\
        modify [ebx]\

void copybuf(void *src, void *dst, long len);
#pragma aux copybuf =\
        "rep movsd",\
        parm [esi][edi][ecx]\
        modify exact [ecx esi edi]\

void copybufbyte(void *src, void *dst, long len);
#pragma aux copybufbyte =\
        "cmp ecx, 4",\
        "jae longcopy",\
        "test cl, 1",\
        "jz preskip",\
        "movsb",\
        "preskip: shr ecx, 1",\
        "rep movsw",\
        "jmp endit",\
        "longcopy: test edi, 1",\
        "jz skip1",\
        "movsb",\
        "dec ecx",\
        "skip1: test edi, 2",\
        "jz skip2",\
        "movsw",\
        "sub ecx, 2",\
        "skip2: mov ebx, ecx",\
        "shr ecx, 2",\
        "rep movsd",\
        "test bl, 2",\
        "jz skip3",\
        "movsw",\
        "skip3: test bl, 1",\
        "jz endit",\
        "movsb",\
        "endit:",\
        parm [esi][edi][ecx]\
        modify [ebx]\

void copybufreverse(void *src, void *dst, long len);
#pragma aux copybufreverse =\
        "shr ecx, 1",\
        "jnc skipit1",\
        "mov al, byte ptr [esi]",\
        "dec esi",\
        "mov byte ptr [edi], al",\
        "inc edi",\
        "skipit1: shr ecx, 1",\
        "jnc skipit2",\
        "mov ax, word ptr [esi-1]",\
        "sub esi, 2",\
        "ror ax, 8",\
        "mov word ptr [edi], ax",\
        "add edi, 2",\
        "skipit2: test ecx, ecx",\
        "jz endloop",\
        "begloop: mov eax, dword ptr [esi-3]",\
        "sub esi, 4",\
        "bswap eax",\
        "mov dword ptr [edi], eax",\
        "add edi, 4",\
        "dec ecx",\
        "jnz begloop",\
        "endloop:",\
        parm [esi][edi][ecx]\

void qinterpolatedown16(long *i1, long i2, long i3, long i4);
#pragma aux qinterpolatedown16 =\
        "mov ebx, ecx",\
        "shr ecx, 1",\
        "jz skipbegcalc",\
        "begqcalc: lea edi, [edx+esi]",\
        "sar edx, 16",\
        "mov dword ptr [eax], edx",\
        "lea edx, [edi+esi]",\
        "sar edi, 16",\
        "mov dword ptr [eax+4], edi",\
        "add eax, 8",\
        "dec ecx",\
        "jnz begqcalc",\
        "test ebx, 1",\
        "jz skipbegqcalc2",\
        "skipbegcalc: sar edx, 16",\
        "mov dword ptr [eax], edx",\
        "skipbegqcalc2:",\
        parm [eax][ecx][edx][esi]\
        modify exact [eax ebx ecx edx edi]\

void qinterpolatedown16short(long *i1, long i2, long i3, long i4);
#pragma aux qinterpolatedown16short =\
        "test ecx, ecx",\
        "jz endit",\
        "test al, 2",\
        "jz skipalignit",\
        "mov ebx, edx",\
        "sar ebx, 16",\
        "mov word ptr [eax], bx",\
        "add edx, esi",\
        "add eax, 2",\
        "dec ecx",\
        "jz endit",\
        "skipalignit: sub ecx, 2",\
        "jc finishit",\
        "begqcalc: mov ebx, edx",\
        "add edx, esi",\
        "sar ebx, 16",\
        "mov edi, edx",\
        "and edi, 0ffff0000h",\
        "add edx, esi",\
        "add ebx, edi",\
        "mov dword ptr [eax], ebx",\
        "add eax, 4",\
        "sub ecx, 2",\
        "jnc begqcalc",\
        "test cl, 1",\
        "jz endit",\
        "finishit: mov ebx, edx",\
        "sar ebx, 16",\
        "mov word ptr [eax], bx",\
        "endit:",\
        parm [eax][ecx][edx][esi]\
        modify exact [eax ebx ecx edx edi]\


#if (defined PLATFORM_DOS)   /* !!! move this to dos_driver.c? */

void setcolor16(int i1);
#pragma aux setcolor16 =\
        "mov dx, 0x3ce",\
        "shl ax, 8",\
        "out dx, ax",\
        parm [eax]\
        modify exact [eax edx]\

#endif  /* defined PLATFORM_DOS */


void vlin16first(long i1, long i2);
#pragma aux vlin16first =\
        "mov al, byte ptr [edi]",\
        "mov eax, ecx",\
        "shr ecx, 2",\
        "begvlin16firsta: mov byte ptr [edi], al",\
        "mov byte ptr [edi+80], al",\
        "mov byte ptr [edi+160], al",\
        "mov byte ptr [edi+240], al",\
        "add edi, 320",\
        "dec ecx",\
        "jnz begvlin16firsta",\
        "mov ecx, eax",\
        "and ecx, 3",\
        "jz skipfirst",\
        "begvlin16firstb: mov byte ptr [edi], al",\
        "add edi, 80",\
        "dec ecx",\
        "jnz begvlin16firstb",\
        "skipfirst:",\
        parm [edi][ecx]\
        modify exact [eax ecx edi]\

void vlin16(long i1, long i2);
#pragma aux vlin16 =\
        "mov esi, edi",\
        "begvlin16: movsb",\
        "add edi, 79",\
        "add esi, 79",\
        "dec ecx",\
        "jnz begvlin16",\
        parm [edi][ecx]\
        modify exact [ecx esi edi]\

#if (defined PLATFORM_DOS)   /* !!! move this to dos_driver.c? */

void drawpixel16(long offset);
#pragma aux drawpixel16 =\
        "mov ecx, edi",\
        "mov eax, 0x00008008",\
        "mov dx, 0x3ce",\
        "ror ah, cl",\
        "shr edi, 3",\
        "out dx, ax",\
        "mov cl, byte ptr [edi+0xa0000]",\
        "mov byte ptr [edi+0xa0000], al",\
        parm [edi]\
        modify exact [eax ecx edx edi]\

void fillscreen16(long i1, long i2, long i3);
#pragma aux fillscreen16 =\
        "mov dx, 0x3ce",\
        "shl ax, 8",\
        "out dx, ax",\
        "mov ax, 0xff08",\
        "out dx, ax",\
        "shr ecx, 5",\
        "add edi, 0xa0000",\
        "rep stosd",\
        parm [edi][eax][ecx]\
        modify exact [eax ecx edx edi]\

void koutp(long i1, long i);
#pragma aux koutp =\
        "out dx, al",\
        parm [edx][eax]\
        modify exact \

void koutpw(long i1, long i);
#pragma aux koutpw =\
        "out dx, ax",\
        parm [edx][eax]\
        modify exact \

int kinp(long i);
#pragma aux kinp =\
        "in al, dx",\
        parm nomemory [edx]\
        modify exact [eax]\

#endif  /* defined PLATFORM_DOS */


long mul3(long i1);
#pragma aux mul3 =\
        "lea eax, [eax+eax*2]",\
        parm nomemory [eax]\

long mul5(long i1);
#pragma aux mul5 =\
        "lea eax, [eax+eax*4]",\
        parm nomemory [eax]\

long mul9(long i1);
#pragma aux mul9 =\
        "lea eax, [eax+eax*8]",\
        parm nomemory [eax]\

        /* returns eax/ebx, dmval = eax%edx; */
long divmod(long i1, long i2);
#pragma aux divmod =\
        "xor edx, edx",\
        "div ebx",\
        "mov dmval, edx",\
        parm [eax][ebx]\
        modify exact [eax edx]\
        value [eax]

        /* returns eax%ebx, dmval = eax/edx; */
long moddiv(long i1, long i2);
#pragma aux moddiv =\
        "xor edx, edx",\
        "div ebx",\
        "mov dmval, eax",\
        parm [eax][ebx]\
        modify exact [eax edx]\
        value [edx]

long klabs(long i1);
#pragma aux klabs =\
        "test eax, eax",\
        "jns skipnegate",\
        "neg eax",\
        "skipnegate:",\
        parm nomemory [eax]\

long ksgn(long i1);
#pragma aux ksgn =\
        "add ebx, ebx",\
        "sbb eax, eax",\
        "cmp eax, ebx",\
        "adc al, 0",\
        parm nomemory [ebx]\
        modify exact [eax ebx]\

        /* eax = (unsigned min)umin(eax,ebx) */
long umin(long i1, long i2);
#pragma aux umin =\
        "sub eax, ebx",\
        "sbb ecx, ecx",\
        "and eax, ecx",\
        "add eax, ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax ecx]\

        /* eax = (unsigned max)umax(eax,ebx) */
long umax(long i1, long i2);
#pragma aux umax =\
        "sub eax, ebx",\
        "sbb ecx, ecx",\
        "xor ecx, 0xffffffff",\
        "and eax, ecx",\
        "add eax, ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax ecx]\

long kmin(long i1, long i2);
#pragma aux kmin =\
        "cmp eax, ebx",\
        "jl skipit",\
        "mov eax, ebx",\
        "skipit:",\
        parm nomemory [eax][ebx]\
        modify exact [eax]\

long kmax(long i1, long i2);
#pragma aux kmax =\
        "cmp eax, ebx",\
        "jg skipit",\
        "mov eax, ebx",\
        "skipit:",\
        parm nomemory [eax][ebx]\
        modify exact [eax]\

#if (defined PLATFORM_DOS)  /* !!! move to dos_driver.c? */
void limitrate(void);
#pragma aux limitrate =\
        "mov dx, 0x3da",\
        "wait1: in al, dx",\
        "test al, 8",\
        "jnz wait1",\
        "wait2: in al, dx",\
        "test al, 8",\
        "jz wait2",\
        modify exact [eax edx]\

long readtimer(void);
#pragma aux readtimer =\
        "mov al, 0xd2",\
        "out 0x43, al",\
        "in al, 0x40",\
        "shl eax, 24",\
        "in al, 0x40",\
        "rol eax, 8",\
        modify [eax]\

void redblueblit(void *i1, void *i2, long i3);
#pragma aux redblueblit = \
        "xor ecx, ecx",\
        "begblit: mov eax, dword ptr [edx+ecx]",\
        "shl eax, 4",\
        "add eax, dword ptr [ebx+ecx]",\
        "mov dword ptr [ecx+0xa0000], eax",\
        "add ecx, 4",\
        "cmp ecx, esi",\
        "jb begblit",\
        parm [ebx][edx][esi]\
        modify exact [eax ecx]\

#pragma aux chainblit =\
        "shr ecx, 1",\
        "jnc prebeg",\
        "mov al, byte ptr [esi+8]",\
        "mov ah, byte ptr [esi+12]",\