pragmas.h

小型游戏引擎

        "shl eax, 16",\
        "mov al, byte ptr [esi]",\
        "mov ah, byte ptr [esi+4]",\
        "mov dword ptr [edi], eax",\
        "add esi, 16",\
        "add edi, 4",\
        "test ecx, ecx",\
        "prebeg: jz endit",\
        "beg: mov al, byte ptr [esi+8]",\
        "mov bl, byte ptr [esi+24]",\
        "mov ah, byte ptr [esi+12]",\
        "mov bh, byte ptr [esi+28]",\
        "shl eax, 16",\
        "add edi, 8",\
        "shl ebx, 16",\
        "mov al, byte ptr [esi]",\
        "mov bl, byte ptr [esi+16]",\
        "mov ah, byte ptr [esi+4]",\
        "mov bh, byte ptr [esi+20]",\
        "add esi, 32",\
        "mov dword ptr [edi-8], eax",\
        "dec ecx",\
        "mov dword ptr [edi-4], ebx",\
        "jnz beg",\
        "endit:",\
        parm [esi][edi][ecx]\
        modify exact [eax ebx ecx esi edi]\

#endif


void swapchar(char *i1, char *i2);
#pragma aux swapchar =\
        "mov cl, [eax]",\
        "mov ch, [ebx]",\
        "mov [ebx], cl",\
        "mov [eax], ch",\
        parm [eax][ebx]\
        modify exact [ecx]\

void swapshort(short *i1, short *i2);
#pragma aux swapshort =\
        "mov cx, [eax]",\
        "mov dx, [ebx]",\
        "mov [ebx], cx",\
        "mov [eax], dx",\
        parm [eax][ebx]\
        modify exact [ecx edx]\

void swaplong(long *i1, long *i2);
#pragma aux swaplong =\
        "mov ecx, [eax]",\
        "mov edx, [ebx]",\
        "mov [ebx], ecx",\
        "mov [eax], edx",\
        parm [eax][ebx]\
        modify exact [ecx edx]\

#pragma aux swapbuf4 =\
        "begswap:",\
        "mov esi, [eax]",\
        "mov edi, [ebx]",\
        "mov [ebx], esi",\
        "mov [eax], edi",\
        "add eax, 4",\
        "add ebx, 4",\
        "dec ecx",\
        "jnz short begswap",\
        parm [eax][ebx][ecx]\
        modify exact [eax ebx ecx esi edi]\

#pragma aux swap64bit =\
        "mov ecx, [eax]",\
        "mov edx, [ebx]",\
        "mov [ebx], ecx",\
        "mov ecx, [eax+4]",\
        "mov [eax], edx",\
        "mov edx, [ebx+4]",\
        "mov [ebx+4], ecx",\
        "mov [eax+4], edx",\
        parm [eax][ebx]\
        modify exact [ecx edx]\


        /*
         * swapchar2(ptr1,ptr2,xsiz); is the same as:
         * swapchar(ptr1,ptr2); swapchar(ptr1+1,ptr2+xsiz);
		 */ 
void swapchar2(char *ptr1, char *ptr2, long xsiz);
#pragma aux swapchar2 =\
        "add esi, ebx",\
        "mov cx, [eax]",\
        "mov dl, [ebx]",\
        "mov [ebx], cl",\
        "mov dh, [esi]",\
        "mov [esi], ch",\
        "mov [eax], dx",\
        parm [eax][ebx][esi]\
        modify exact [ecx edx esi]\

static long timeroffs1mhz;
        /* accutimeroffs = -8-(t1-t0); */
#pragma aux inittimer1mhz =\
        "xor ebx, ebx",\
        "xor ecx, ecx",\
        "in al, 0x61",\
        "or al, 1",\
        "out 0x61, al",\
        "mov al, 0x34",\
        "out 0x43, al",\
        "xor al, al",\
        "out 0x40, al",\
        "mov al, 0xb4",\
        "out 0x43, al",\
        "mov al, 240",\
        "out 0x42, al",\
        "xor al, al",\
        "cli",\
        "out 0x40, al",\
        "dec al",\
        "out 0x42, al",\
        "mov al, 0x04",\
        "out 0x43, al",\
        "in al, 0x40",\
        "mov bl, al",\
        "in al, 0x40",\
        "mov bh, al",\
        "mov al, 0x84",\
        "out 0x43, al",\
        "in al, 0x42",\
        "mov cl, al",\
        "in al, 0x42",\
        "sti",\
        "mov ch, al",\
        "sub ebx, ecx",\
        "sub ebx, 8",\
        "mov timeroffs1mhz, ebx",\
        modify exact [eax ebx ecx]\

#pragma aux uninittimer1mhz =\
        "in al, 0x61",\
        "and al, 252",\
        "out 0x61, al",\
        modify exact [eax]\

        /* t = ((ecx-ebx+timeroffs1mhz)&0xfff0)*4095 + ecx; */
#pragma aux gettime1mhz =\
        "mov ebx, timeroffs1mhz",\
        "xor ecx, ecx",\
        "mov al, 0x04",\
        "cli",\
        "out 0x43, al",\
        "in al, 0x40",\
        "sub bl, al",\
        "in al, 0x40",\
        "sbb bh, al",\
        "mov al, 0x84",\
        "out 0x43, al",\
        "in al, 0x42",\
        "mov cl, al",\
        "in al, 0x42",\
        "sti",\
        "mov ch, al",\
        "add ebx, ecx",\
        "and ebx, 0x0000fff0",\
        "sub ecx, ebx",\
        "shl ebx, 12",\
        "add ebx, ecx",\
        modify exact [eax ebx ecx]\
        value [ebx]\

        /* eax = eax-ebx; if (eax < 0) eax += (1<<28) - (1<<16); */
#pragma aux deltatime1mhz =\
        "sub eax, ebx",\
        "jnc skipit",\
        "add eax, 0x0fff0000",\
        "skipit:",\
        parm [ebx][eax]

#pragma aux boundmulscale =\
        "imul ebx",\
        "mov ebx, edx",\
        "shrd eax, edx, cl",\
        "sar edx, cl",\
        "xor edx, eax",\
        "js checkit",\
        "xor edx, eax",\
        "jz skipboundit",\
        "cmp edx, 0xffffffff",\
        "je skipboundit",\
        "checkit:",\
        "mov eax, ebx",\
        "sar eax, 31",\
        "xor eax, 0x7fffffff",\
        "skipboundit:",\
        parm nomemory [eax][ebx][ecx]\
        modify exact [eax ebx edx]\

long divscale(long i1, long i2, long i3);
#pragma aux divscale =\
        "mov edx, eax",\
        "shl eax, cl",\
        "neg cl",\
        "sar edx, cl",\
        "idiv ebx",\
        parm nomemory [eax][ebx][ecx]\
        modify exact [eax ecx edx]
        
long divscale1(long i1, long i2);
#pragma aux divscale1 =\
        "add eax, eax",\
        "sbb edx, edx",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]
        
long divscale2(long i1, long i2);
#pragma aux divscale2 =\
        "mov edx, eax",\
        "sar edx, 30",\
        "lea eax, [eax*4]",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

long divscale3(long i1, long i2);
#pragma aux divscale3 =\
        "mov edx, eax",\
        "sar edx, 29",\
        "lea eax, [eax*8]",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        modify exact [eax edx]\

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

long divscale26(long i1, long i2);
#pragma aux divscale26 =\
        "mov edx, eax",\
        "sar edx, 6",\
        "shl eax, 26",\
        "idiv ebx",\
        parm nomemory [eax][ebx]\
        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]

#else  /* non-Watcom platforms land here: */


/* These are not defines, so they land in pragma.c for ASM and non-ASM. */
void swapchar(unsigned char *p1, unsigned char *p2)