blocksort.c File Reference

#include "bzlib_private.h"

Macros
#define	fswap(zz1, zz2)
#define	fvswap(zzp1, zzp2, zzn)
#define	fmin(a, b)
#define	fpush(lz, hz)
#define	fpop(lz, hz)
#define	FALLBACK_QSORT_SMALL_THRESH   10
#define	FALLBACK_QSORT_STACK_SIZE   100
#define	SET_BH(zz)
#define	CLEAR_BH(zz)
#define	ISSET_BH(zz)
#define	WORD_BH(zz)
#define	UNALIGNED_BH(zz)
#define	mswap(zz1, zz2)
#define	mvswap(zzp1, zzp2, zzn)
#define	mmin(a, b)
#define	mpush(lz, hz, dz)
#define	mpop(lz, hz, dz)
#define	mnextsize(az)
#define	mnextswap(az, bz)
#define	MAIN_QSORT_SMALL_THRESH   20
#define	MAIN_QSORT_DEPTH_THRESH   (BZ_N_RADIX + BZ_N_QSORT)
#define	MAIN_QSORT_STACK_SIZE   100
#define	BIGFREQ(b)
#define	SETMASK   (1 << 21)
#define	CLEARMASK   (~(SETMASK))

Functions
void	BZ2_blockSort (EState *s)

Macro Definition Documentation

BIGFREQ

#define BIGFREQ

(

b

)

Value:

(ftab[((b)+1) << 8] - ftab[(b) << 8])

CLEAR_BH

#define CLEAR_BH

(

zz

)

Value:

bhtab[(zz) >> 5] &= ~((UInt32)1 << ((zz) & 31))

CLEARMASK

#define CLEARMASK   (~(SETMASK))

FALLBACK_QSORT_SMALL_THRESH

#define FALLBACK_QSORT_SMALL_THRESH   10

FALLBACK_QSORT_STACK_SIZE

#define FALLBACK_QSORT_STACK_SIZE   100

fmin

#define fmin	(		a,
			b )

Value:

((a) < (b)) ? (a) : (b)

fpop

#define fpop	(		lz,
			hz )

Value:

                      { sp--;              \
                      lz = stackLo[sp];  \
                      hz = stackHi[sp]; }

fpush

#define fpush	(		lz,
			hz )

Value:

                       { stackLo[sp] = lz; \
                       stackHi[sp] = hz; \
                       sp++; }

fswap

#define fswap	(		zz1,
			zz2 )

Value:

   { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }

fvswap

#define fvswap	(		zzp1,
			zzp2,
			zzn )

Value:

{                                     \
   Int32 yyp1 = (zzp1);               \
   Int32 yyp2 = (zzp2);               \
   Int32 yyn  = (zzn);                \
   while (yyn > 0) {                  \
      fswap(fmap[yyp1], fmap[yyp2]);  \
      yyp1++; yyp2++; yyn--;          \
   }                                  \
}

ISSET_BH

#define ISSET_BH

(

zz

)

Value:

(bhtab[(zz) >> 5] & ((UInt32)1 << ((zz) & 31)))

MAIN_QSORT_DEPTH_THRESH

#define MAIN_QSORT_DEPTH_THRESH   (BZ_N_RADIX + BZ_N_QSORT)

MAIN_QSORT_SMALL_THRESH

#define MAIN_QSORT_SMALL_THRESH   20

MAIN_QSORT_STACK_SIZE

#define MAIN_QSORT_STACK_SIZE   100

mmin

#define mmin	(		a,
			b )

Value:

((a) < (b)) ? (a) : (b)

mnextsize

#define mnextsize

(

az

)

Value:

(nextHi[az]-nextLo[az])

mnextswap

#define mnextswap	(		az,
			bz )

Value:

   { Int32 tz;                                                  \
     tz = nextLo[az]; nextLo[az] = nextLo[bz]; nextLo[bz] = tz; \
     tz = nextHi[az]; nextHi[az] = nextHi[bz]; nextHi[bz] = tz; \
     tz = nextD [az]; nextD [az] = nextD [bz]; nextD [bz] = tz; }

mpop

#define mpop	(		lz,
			hz,
			dz )

Value:

                         { sp--;             \
                         lz = stackLo[sp]; \
                         hz = stackHi[sp]; \
                         dz = stackD [sp]; }

mpush

#define mpush	(		lz,
			hz,
			dz )

Value:

                          { stackLo[sp] = lz; \
                          stackHi[sp] = hz; \
                          stackD [sp] = dz; \
                          sp++; }

mswap

#define mswap	(		zz1,
			zz2 )

Value:

   { Int32 zztmp = zz1; zz1 = zz2; zz2 = zztmp; }

mvswap

#define mvswap	(		zzp1,
			zzp2,
			zzn )

Value:

{                                     \
   Int32 yyp1 = (zzp1);               \
   Int32 yyp2 = (zzp2);               \
   Int32 yyn  = (zzn);                \
   while (yyn > 0) {                  \
      mswap(ptr[yyp1], ptr[yyp2]);    \
      yyp1++; yyp2++; yyn--;          \
   }                                  \
}

SET_BH

#define SET_BH

(

zz

)

Value:

bhtab[(zz) >> 5] |= ((UInt32)1 << ((zz) & 31))

SETMASK

#define SETMASK   (1 << 21)

UNALIGNED_BH

#define UNALIGNED_BH

(

zz

)

Value:

((zz) & 0x01f)

WORD_BH

#define WORD_BH

(

zz

)

Value:

bhtab[(zz) >> 5]

Function Documentation

BZ2_blockSort()

void BZ2_blockSort

(

EState *

s

)