#include "stdafx.h"
#pragma hdrstop
/*

  Copyright (c) 1990-2007 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2007-Mar-4 or later
  (the contents of which are also included in zip.h) for terms of use.
  If, for some reason, all these files are missing, the Info-ZIP license
  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html

  parts Copyright (C) 1997 Mike White, Eric W. Engler
************************************************************************
 Copyright (C) 2009, 2010  by Russell J. Peters, Roger Aelbrecht

   This file is part of TZipMaster Version 1.9.

    TZipMaster is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    TZipMaster is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public License
    along with TZipMaster.  If not, see <http://www.gnu.org/licenses/>.

    contact: problems@delphizip.org (include ZipMaster in the subject).
    updates: http://www.delphizip.org
    DelphiZip maillist subscribe at http://www.freelists.org/list/delphizip 
************************************************************************/
#ifdef _USE_ASM_
	#if defined(__BORLANDC__) && (__BORLANDC__ < 0x0570)
	#pragma inline
	#endif

#include "ZipDflt.h"

void __fastcall ZipDflt::pqdownheap(ct_data *tree, int k)
{
#pragma warn - rvl
#pragma argsused
//  int v, j, b;
    int v = fheap[k];
    int j = k << 1;       // left son of k
    int htemp;
    asm
    {

l1:
        mov       ebx, this
        // ebx = this
        //   While (j <= fheap_len)
        mov       edx, j
        cmp       edx, dword ptr [ebx .fheap_len]
        jg        lx
        //    if (J < fheap_len
        jge       l3
        //      && smaller
        //      tree[j + 1].Freq < tree[j].Freq
        mov       ecx, tree
        mov       edx, j
        mov       edx, dword ptr [ebx+4*edx .fheap+4]
        mov       ax, word ptr [ecx+4*edx]
        mov       edx, j
        mov       edx, dword ptr [ebx+4*edx .fheap]
        cmp       ax, word ptr [ecx+4*edx]
        jb        short l2
        // || (tree[n].Freq == tree[m].Freq
        jne       short l3
        //  && fdepth[j + 1] <= fdepth[j])
        mov       eax, j
        mov       edx, this
        mov       eax, dword ptr [ebx+4*eax .fheap+4]
        mov       cl, byte ptr [ebx+eax .fdepth]
        mov       eax, j
        mov       eax, dword ptr [ebx+4*eax .fheap]
        cmp       cl, byte ptr [ebx+eax .fdepth]
        ja        short l3

l2:
        //    j++
        inc       j

l3:
        // Exit if v is smaller than both sons
        //   htemp = fheap[j];
        mov       ecx, j
        mov       edx, dword ptr [ebx+4*ecx .fheap]
        mov       htemp, edx
        //      if (smaller(tree, v, htemp)
        //      tree[v].Freq < tree[htemp].Freq
        mov       ecx, tree
        mov       eax, v
        mov       dx, word ptr [ecx+4*eax]
        mov       eax, htemp
        cmp       dx, word ptr [ecx+4*eax]
        jb        short lx
        // || (tree[v].Freq == tree[htemp].Freq
        jne       short l4
        //  && fdepth[v] <= fdepth[htemp])
        mov       eax, v
        mov       cl, byte ptr [ebx+eax .fdepth]
        mov       eax, htemp
        cmp       cl, byte ptr [ebx+eax .fdepth]
        jbe       short lx

l4:
        // Exchange v with the smallest son
        //    fheap[k] = htemp;
        mov       ecx, k
        mov       edx, htemp
        mov       dword ptr [ebx+4*ecx .fheap], edx

        //    k = j;
        mov       ecx, j
        mov       k, ecx

        // And continue down the tree, setting j to the left son of k
        //    j <<= 1;
        shl       j, 1
	#if defined(__BORLANDC__) && (__BORLANDC__ < 0x0550)
        jmp       l1
	#else
        jmp       short l1
	#endif
        // } while

lx:
        //  fheap[k] = v;
        mov       ecx, k
        mov       eax, this
        mov       edx, v
        mov       dword ptr [eax+4*ecx .fheap], edx
        // fini
    };
};



unsigned __fastcall bi_reverse(unsigned code, int len)
{
#pragma warn - rvl
#pragma argsused
    asm
    {
        // EAX=code EDX=len
        mov ecx, eax
        xor eax, eax

Loop1:
        dec edx
        jl short doneit
        ror ecx, 1
        rcl eax, 1
        jmp short Loop1

doneit:
    };
}


#endif