rad.h

RadGameTools_Bink_SDK.rar and older version

      char* radstrlwr(void* s1);
      #pragma aux radstrlwr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'A'" "jb c1" "cmp al,'Z'" "ja c1" "add [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];

      u32 radstru32(const void* dest);
        #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
        "skip:" "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
        parm [ESI] modify [EAX EBX EDX EDI ESI] value [ecx];
                                                             
      u16 GetDS();
      #pragma aux GetDS = "mov ax,ds" value [ax];

      #ifdef __RADWINEXT__
    
        #define _16To32(ptr16) ((void*)(((GetSelectorBase((u16)(((u32)(ptr16))>>16))+((u16)(u32)(ptr16)))-GetSelectorBase(GetDS()))))

      #endif

      #ifndef __RADWIN__
        #define int86 int386
        #define int86x int386x
      #endif
    
      #define u32regs x
      #define u16regs w
    
    #else

      #define radstrcpy strcpy
      #define radstrcat strcat
      #define radmemcpy memcpy
      #define radmemcpydb memmove
      #define radmemcmp memcmp
      #define radmemset memset
      #define radstrlen strlen
      #define radstrchr strchr
      #define radtoupper toupper
      #define radstru32(s) ((u32)atol(s))
      #define radstricmp _stricmp
      #define radstrcmp strcmp
      #define radstrupr _strupr
      #define radstrlwr _strlwr
      #define BreakPoint() _asm {int 3}

      #ifdef _MSC_VER

        #pragma warning( disable : 4035)

        typedef char* RADPCHAR;

        u32 __inline radsqr(u32 m) { 
          _asm { 
            mov eax,[m] 
            mul eax 
          }
        }

        u32 __inline mult64anddiv(u32 m1,u32 m2, u32 d) { 
          _asm { 
            mov eax,[m1] 
            mov ecx,[m2] 
            mul ecx 
            mov ecx,[d] 
            div ecx 
          } 
        }

        s32 __inline radabs(s32 ab) { 
          _asm { 
            mov eax,[ab] 
            test eax,eax 
            jge skip 
            neg eax 
           skip:
          } 
        }

        u8 __inline radinp(u16 p) { 
          _asm { 
            mov dx,[p] 
            in al,dx 
          } 
        }

        void __inline radoutp(u16 p,u8 v) { 
          _asm { 
            mov dx,[p] 
            mov al,[v] 
            out dx,al 
          } 
        }

        RADPCHAR __inline radstpcpy(char* p1, char* p2) { 
          _asm { 
             mov edx,[p1] 
             mov ecx,[p2] 
             cld 
            lp: 
             mov al,[ecx] 
             inc ecx 
             mov [edx],al 
             inc edx 
             cmp al,0 
             jne lp 
             dec edx 
             mov eax,edx 
          } 
        }
        
        RADPCHAR __inline radstpcpyrs(char* p1, char* p2) { 
          _asm { 
            mov edx,[p1] 
            mov ecx,[p2] 
            cld 
           lp: 
            mov al,[ecx] 
            inc ecx 
            mov [edx],al
            inc edx 
            cmp al,0 
            jne lp 
            dec ecx 
            mov eax,ecx 
          } 
        }

        void __inline radmemset16(void* dest,u16 value,u32 sizeb) {
          _asm { 
            mov edi,[dest] 
            mov ax,[value] 
            mov ecx,[sizeb] 
            shl eax,16 
            cld 
            mov ax,[value] 
            mov bl,cl 
            shr ecx,1 
            rep stosd 
            mov cl,bl 
            and cl,1 
            rep stosw
          }
        }

        void __inline radmemset32(void* dest,u32 value,u32 sizeb) {
          _asm {
            mov edi,[dest]
            mov eax,[value]
            mov ecx,[sizeb]
            cld
            rep stosd
          }
        }

        u32 __inline __stdcall RADsqrt(u32 sq) {
          _asm {
            fild dword ptr [sq]
            fsqrt
            fistp word ptr [sq]
            movzx eax,word ptr [sq]
          }
        }

        void __inline RADCycleTimerStartAddr(u32* addr)
        {
          _asm {
            mov ecx,[addr]
            __asm __emit 0fh __asm __emit 031h
            mov [ecx],eax
          }
        }

        u32 __inline RADCycleTimerDeltaAddr(u32* addr)
        {
          _asm {
            __asm __emit 0fh __asm __emit 031h
            mov ecx,[addr]
            sub eax,[ecx]
          }
        }

        #define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
        #define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)

        #pragma warning( default : 4035)

      #endif

    #endif

  #endif

#else

  #define PTR4 __far
  
  #define u16 unsigned int
  #define s16 signed int

  #ifdef __WATCOMC__
    
    u32 radsqr(s32 a);
    #pragma aux radsqr = "shl edx,16" "mov dx,ax" "mov eax,edx" "xor edx,edx" "mul eax" "shld edx,eax,16" parm [dx ax] modify [DX ax] value [dx ax];

    s16 radabs(s16 ab);
    #pragma aux radabs = "test ax,ax" "jge skip" "neg ax" "skip:" parm [ax] value [ax];
    
    s32 radabs32(s32 ab);
    #pragma aux radabs32 = "test dx,dx" "jge skip" "neg dx" "neg ax" "sbb dx,0" "skip:" parm [dx ax] value [dx ax];
    
    u32 DOSOut(const char far* dest);
    #pragma aux DOSOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "mov bx,1" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
       parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
    
    void DOSOutNum(const char far* str,u16 len);
    #pragma aux DOSOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "mov bx,1" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];

    u32 ErrOut(const char far* dest);
    #pragma aux ErrOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "xor bx,bx" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
       parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
    
    void ErrOutNum(const char far* str,u16 len);
    #pragma aux ErrOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "xor bx,bx" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];

    void radmemset(void far *dest,u8 value,u32 size);
    #pragma aux radmemset = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" 0x67 "rep stosd" "mov cl,bl" "and cl,3" "rep stosb" parm [ES DI] [AL] [CX BX];
    
    void radmemset16(void far* dest,u16 value,u32 size);
    #pragma aux radmemset16 = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [ES DI] [AX] [CX BX];

    void radmemcpy(void far* dest,const void far* source,u32 size);
    #pragma aux radmemcpy = "cld" "push ds" "mov ds,dx" "and esi,0ffffh" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "shr ecx,2" 0x67 "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
    
    s8 radmemcmp(const void far* s1,const void far* s2,u32 len);
    #pragma aux radmemcmp = "cld" "push ds" "mov ds,dx" "shl ecx,16" "mov cx,bx" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" "pop ds"  parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];

    char far* radstrcpy(void far* dest,const void far* source);
    #pragma aux radstrcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "mov dx,di" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" parm [ES DI] [DX SI] modify [AX DX DI SI ES] value [es dx];

    char far* radstpcpy(void far* dest,const void far* source);
    #pragma aux radstpcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "dec di" "pop ds" parm [ES DI] [DX SI] modify [DI SI ES] value [es di];

    u32 radstrlen(const void far* dest);
    #pragma aux radstrlen = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "movzx eax,cx" "shr ecx,16" parm [ES DI] modify [AX CX DI ES] value [CX AX];
    
    char far* radstrcat(void far* dest,const void far* source);
    #pragma aux radstrcat = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "and esi,0xffff" "push ds" "mov ds,dx" "mov dx,di" "xor eax,eax" 0x67 "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" \
      parm [ES DI] [DX SI] modify [AX CX DI SI ES] value [es dx];
    
    char far* radstrchr(const void far* dest,char chr);
    #pragma aux radstrchr = "cld" "lp:" 0x26 "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "xor ax,ax" "mov es,ax" "mov si,1" "fnd:" "dec si" parm [ES SI] [DL] modify [AX SI ES] value [es si];
    
    s8 radstricmp(const void far* s1,const void far* s2);                                                                       
    #pragma aux radstricmp = "and edi,0xffff" "push ds" "mov ds,dx" "and esi,0xffff" "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" \
      "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
      "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" "pop ds" \
      parm [ES DI] [DX SI] modify [AX DI SI];

    u32 radstru32(const void far* dest);
    #pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" 0x26 "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
      "skip:" 0x26 "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
      "movzx eax,cx" "shr ecx,16" parm [ES SI] modify [AX BX DX DI SI] value [cx ax];

    u32 mult64anddiv(u32 m1,u32 m2,u32 d);
    #pragma aux mult64anddiv = "shl ecx,16" "mov cx,ax" "shrd eax,edx,16" "mov ax,si" "mul ecx" "shl edi,16" "mov di,bx" "div edi" "shld edx,eax,16" "and edx,0xffff" "and eax,0xffff" parm [cx ax] [dx si] [di bx] \
      modify [ax bx cx dx si di] value [dx ax];
    
  #endif

#endif

RADDEFEND

#define u32neg1 ((u32)(s32)-1)
#define RAD_align(var) var; u8 junk##var[4-(sizeof(var)&3)]; 
#define RAD_align_after(var) u8 junk##var[4-(sizeof(var)&3)]={0}; 
#define RAD_align_init(var,val) var=val; u8 junk##var[4-(sizeof(var)&3)]={0};
#define RAD_align_array(var,num) var[num]; u8 junk##var[4-(sizeof(var)&3)];
#define RAD_align_string(var,str) char var[]=str; u8 junk##var[4-(sizeof(var)&3)]={0};

RADEXPFUNC void PTR4* RADEXPLINK radmalloc(u32 numbytes);
RADEXPFUNC void RADEXPLINK radfree(void PTR4* ptr);

#ifdef __WATCOMC__

  char bkbhit();
  #pragma aux bkbhit = "mov ah,1" "int 0x16" "lahf" "shr eax,14" "and eax,1" "xor al,1" ;

  char bgetch();
  #pragma aux bgetch = "xor ah,ah" "int 0x16" "test al,0xff" "jnz done" "mov al,ah" "or al,0x80" "done:" modify [AX];

  void BreakPoint();
  #pragma aux BreakPoint = "int 3";

  u8 radinp(u16 p);
  #pragma aux radinp = "in al,dx" parm [DX];
    
  u8 radtoupper(u8 p);
  #pragma aux radtoupper = "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" parm [al] value [al];
    
  void radoutp(u16 p,u8 v);
  #pragma aux radoutp = "out dx,al" parm [DX] [AL];

#endif

// for multi-processor machines

#ifdef __RADNT__
  #define LockedIncrement(var) _asm { lock inc [var] }
  #define LockedDecrement(var) _asm { lock dec [var] }
#else
  #define LockedIncrement(var) _asm { inc [var] }
  #define LockedDecrement(var) _asm { dec [var] }
#endif

#endif

#endif