メインページ | アルファベット順一覧 | 構成 | ファイル一覧 | 構成メンバ | ファイルメンバ | 関連ページ

# dkcBit.h

bit演算関連 [詳細]

`#include "dkcMemoryStream.h"`
`#include "dkcSJISFileSystem.h"`

dkcBit.hのインクルード依存関係図

このグラフは、どのファイルから直接、間接的にインクルードされているかを示しています。

ソースコードを見る。

## 構成
union | dkc_NLZ8Byte
union | dkc_NLZ4Byte
struct | dkc_BitMemoryStream
| ビットを出力するメモリストリーム [詳細]
## マクロ定義
#define | DKUTIL_C_USE_BIT_TABLE 0
#define | dkcNumOfBits(bits) dkcPOP(bits)
#define | dkcBitMemoryStreamGetMemoryStreamObj(p) p->pms
#define | dkcBitMemoryStreamTellByte(ptr) dkcMemoryStreamTell(ptr->pms)
| バイト単位で今のシーク位置（オフセット）を取得する
#define | dkcBitMemoryStreamWriteToMemory(ptr, dest, size, flag) dkcMemoryStreamWriteToMemory(ptr->pms,dest,size,flag)
#define | dkcBitMemoryStreamWriteToMemoryLast(ptr, dest, size, flag) dkcBitMemoryStreamWriteLast(ptr);dkcBitMemoryStreamWriteToMemory(ptr,dest,size,flag)
| dkcBitMemoryStreamWriteLast() をしてからdkcBitMemoryStreamWriteToMemory()をする。
#define | dkcBitMemoryStreamDump(ptr, filename, flag) dkcMemoryStreamDump(ptr->pms,filename,flag)
#define | dkcBitMemoryStreamLoadFromFile(ptr, filename, permit_size, flag) dkcMemoryStreamLoadFromFile(ptr->pms,filename,permit_size,flag)
#define | dkcBitMemoryStreamLoadFromMemory(ptr, buffer, buffsize) dkcMemoryStreamLoadFromMemory(ptr->pms,buffer,buffsize)
## 型定義
typedef dkc_BitMemoryStream | DKC_BIT_MEMORYSTREAM
| ビットを出力するメモリストリーム
## 列挙型
enum | edkcBitMemoryStream { edkcBitMemoryStreamSeekCurrent = edkcSeekCurrent, edkcBitMemoryStreamSeekEnd = edkcSeekEnd, edkcBitMemoryStreamSeekSet = edkcSeekSet }
## 関数
DKC_FORCE_INLINE size_t | dkcNLZ_IEEE (uint32 arg)
| これには驚き [Henry] p.86
DKC_FORCE_INLINE size_t | dkcNLZ (uint32 x)
| [Henry] p.85
DKC_FORCE_INLINE size_t | dkcPOP (uint32 x)
| bitsに入れたビットの数を数える population count
DKC_FORCE_INLINE size_t | dkcNTZ (uint32 x)
| number of trailing zeros [Henry] p.90
DKC_INLINE DKC_BIT_MEMORYSTREAM * | dkcAllocBitMemoryStream (size_t def_size)
DKC_INLINE int | dkcFreeBitMemoryStream (DKC_BIT_MEMORYSTREAM **p)
DKC_INLINE int | dkcBitMemoryStreamWrite (DKC_BIT_MEMORYSTREAM *p, void *target_arg, int n)
DKC_INLINE int | dkcBitMemoryStreamWriteLast (DKC_BIT_MEMORYSTREAM *p)
DKC_INLINE int | dkcBitMemoryStreamReadBase (DKC_BIT_MEMORYSTREAM *p, void *res_arg, int n, BOOL as_possible_as_much, int *pcount)
DKC_INLINE int | dkcBitMemoryStreamRead (DKC_BIT_MEMORYSTREAM *p, void *res_arg, int n)
DKC_INLINE int WINAPI | dkcBitMemoryStreamReadLast (DKC_BIT_MEMORYSTREAM *p, uint32 *res, int *ressize)
| バッファ内に最後に残っているビットを出力する
DKC_INLINE int WINAPI | dkcBitMemoryStreamSeekByte (DKC_BIT_MEMORYSTREAM *ptr, int offset, int origin)
| バイト単位でシークする シークした場合、構造体内部のステートおよびバッファに蓄えているビットは破棄される
DKC_INLINE int WINAPI | dkcBitMemoryStreamTellBitCheck (DKC_BIT_MEMORYSTREAM *ptr)
DKC_INLINE size_t WINAPI | dkcBitMemoryStreamTellBit (DKC_BIT_MEMORYSTREAM *ptr, size_t *bit)
| ビット単位で今のシーク位置（オフセット）を取得する

## 説明

bit演算関連

作者:
  written and edited by d金魚

参照:
  dkc.hにDKUTIL_C_USE_BIT_TABLEの使い方が書いています。

dkcBit.h で定義されています。

## マクロ定義

#define dkcBitMemoryStreamDump | ( | ptr,
|  | filename,
|  | flag |  | ) | dkcMemoryStreamDump(ptr->pms,filename,flag)

| 参照: dkcMemoryStreamDump() dkcBit.h の 360 行で定義されています。

#define dkcBitMemoryStreamGetMemoryStreamObj | ( | p |  | ) | p->pms

| dkcBit.h の 328 行で定義されています。

#define dkcBitMemoryStreamLoadFromFile | ( | ptr,
|  | filename,
|  | permit_size,
|  | flag |  | ) | dkcMemoryStreamLoadFromFile(ptr->pms,filename,permit_size,flag)

| dkcBit.h の 362 行で定義されています。

#define dkcBitMemoryStreamLoadFromMemory | ( | ptr,
|  | buffer,
|  | buffsize |  | ) | dkcMemoryStreamLoadFromMemory(ptr->pms,buffer,buffsize)

| dkcBit.h の 364 行で定義されています。 参照元 dkcLZWDecode().

#define dkcBitMemoryStreamTellByte | ( | ptr |  | ) | dkcMemoryStreamTell(ptr->pms)

| バイト単位で今のシーク位置（オフセット）を取得する 参照: dkcMemoryStreamTell() dkcBit.h の 339 行で定義されています。 参照元 dkcBitMemoryStreamTellBit(), dkcBitMemoryStreamTellBitCheck(), encode_hash(), と encode_tst().

#define dkcBitMemoryStreamWriteToMemory | ( | ptr,
|  | dest,
|  | size,
|  | flag |  | ) | dkcMemoryStreamWriteToMemory(ptr->pms,dest,size,flag)

| 参照: dkcMemoryStreamWriteToMemory() dkcBit.h の 356 行で定義されています。 参照元 encode_hash(), と encode_tst().

#define dkcBitMemoryStreamWriteToMemoryLast | ( | ptr,
|  | dest,
|  | size,
|  | flag |  | ) | dkcBitMemoryStreamWriteLast(ptr);dkcBitMemoryStreamWriteToMemory(ptr,dest,size,flag)

| dkcBitMemoryStreamWriteLast() をしてからdkcBitMemoryStreamWriteToMemory()をする。 dkcBit.h の 358 行で定義されています。

#define dkcNumOfBits | ( | bits |  | ) | dkcPOP(bits)

| 参照: dkcPOP() dkcBit.h の 90 行で定義されています。

#define DKUTIL_C_USE_BIT_TABLE 0

| dkcBit.h の 14 行で定義されています。

## 型定義

typedef struct dkc_BitMemoryStream DKC_BIT_MEMORYSTREAM

| ビットを出力するメモリストリーム

## 列挙型

enum edkcBitMemoryStream

  | 列挙型の値:
  edkcBitMemoryStreamSeekCurrent | 今の位置からシーク
  edkcBitMemoryStreamSeekEnd | 最後の位置からシーク
  edkcBitMemoryStreamSeekSet | 最初の位置からシーク
dkcBit.h の 108 行で定義されています。
    00108                         {
    00110     edkcBitMemoryStreamSeekCurrent = edkcSeekCurrent,
    00112     edkcBitMemoryStreamSeekEnd = edkcSeekEnd,
    00114     edkcBitMemoryStreamSeekSet = edkcSeekSet,
    00115 };

## 関数

DKC_INLINE DKC_BIT_MEMORYSTREAM* dkcAllocBitMemoryStream | ( | size_t | def_size | ) |

| dkcBit.h の 127 行で定義されています。 参照先 dkcAllocate(), dkcAllocMemoryStream(), dkcFree(), NULL, dkc_BitMemoryStream::pms, と dkc_BitMemoryStream::write_count. 参照元 dkcAllocLZW().
    00128 {
    00129     DKC_BIT_MEMORYSTREAM *p = (DKC_BIT_MEMORYSTREAM *)dkcAllocate(sizeof(DKC_BIT_MEMORYSTREAM));
    00130     if(NULL==p) return NULL;
    00131     p->pms = dkcAllocMemoryStream(def_size);
    00132     if(NULL==p->pms)
    00133         goto End;
    00134
    00135     p->write_count = 8;
    00136
    00137     return p;
    00138 End:
    00139     dkcFree((void **)&p);
    00140     return NULL;
    00141 }

DKC_INLINE int dkcBitMemoryStreamRead | ( | DKC_BIT_MEMORYSTREAM * | p,
|  | void * | res_arg,
|  | int | n
| ) |

| dkcBit.h の 304 行で定義されています。 参照先 dkcBitMemoryStreamReadBase(), と FALSE. 参照元 decode_hash(), と decode_tst().
    00305 {
    00306     int ressize;
    00307     return dkcBitMemoryStreamReadBase(p,res_arg,n,FALSE,&ressize);
    00308 }

DKC_INLINE int dkcBitMemoryStreamReadBase | ( | DKC_BIT_MEMORYSTREAM * | p,
|  | void * | res_arg,
|  | int | n,
|  | BOOL | as_possible_as_much,
|  | int * | pcount
| ) |

| dkcBit.h の 260 行で定義されています。 参照先 dkcMemoryStreamGet8(), dkcMemoryStreamGetSeekPoint(), dkcMemoryStreamSeek(), edkcMemoryStreamSeekSet, dkc_BitMemoryStream::pms, dkc_BitMemoryStream::read_buff, と dkc_BitMemoryStream::read_count. 参照元 dkcBitMemoryStreamRead(), と dkcBitMemoryStreamReadLast().
    00261 {
    00262     int rc = p->read_count;
    00263     size_t rb = p->read_buff;
    00264     size_t result = 0;
    00265     int cc = 0;//counter
    00266 //  size_t rs = 0;
    00267     //save point
    00268     size_t sp = dkcMemoryStreamGetSeekPoint(p->pms);
    00269     uint32 *res = (uint32 *)res_arg;
    00270     if( n <= 0 || n >= 32 ) return edk_FAILED;
    00271     {
    00272         while( --n >= 0 ){
    00273             cc++;
    00274             if( --rc < 0 ){
    00275
    00276                 //if( DKUTIL_FAILED(dkcMemoryStreamRead(p->pms,&rb,1,&rs)) ){
    00277                 if( DKUTIL_FAILED(dkcMemoryStreamGet8(p->pms,(uint8 *)&rb))){
    00278                     if(as_possible_as_much)//がんばって出来るだけ読み込んだよ。
    00279                         goto End;
    00280                     //元の状態に戻す
    00281                     dkcMemoryStreamSeek(p->pms,sp,edkcMemoryStreamSeekSet);
    00282                     return edk_FAILED;
    00283                 }
    00284                 rc = 7;
    00285             }
    00286     #if DKUTIL_C_USE_BIT_TABLE == 1
    00287             if( dkccvBitTable8[rc] & rb ){
    00288                 result |= dkccvBitTable32[n];
    00289             }
    00290     #else
    00291             if( (1 << rc) & rb){
    00292                 result |= (1 << n);
    00293             }
    00294     #endif
    00295         }
    00296     End:
    00297         *res = result;
    00298         p->read_count = rc;
    00299         p->read_buff = rb;
    00300         *pcount = cc;
    00301     }
    00302     return edk_SUCCEEDED;
    00303 }

DKC_INLINE int WINAPI dkcBitMemoryStreamReadLast | ( | DKC_BIT_MEMORYSTREAM * | p,
|  | uint32 * | res,
|  | int * | ressize
| ) |

| バッファ内に最後に残っているビットを出力する 出来るだけ読み込む dkcBit.h の 313 行で定義されています。 参照先 dkcBitMemoryStreamReadBase(), dkc_BitMemoryStream::read_buff, dkc_BitMemoryStream::read_count, と TRUE.
    00314 {
    00315     if(p->read_count <= 0){
    00317         return dkcBitMemoryStreamReadBase(p,
    00318             res,32,TRUE,ressize);
    00319     }
    00320     *res = p->read_buff;
    00321     *ressize = p->read_count;
    00322     p->read_count = p->read_buff = 0;
    00323     return edk_SUCCEEDED;
    00324 }

DKC_INLINE int WINAPI dkcBitMemoryStreamSeekByte | ( | DKC_BIT_MEMORYSTREAM * | ptr,
|  | int | offset,
|  | int | origin
| ) |

| バイト単位でシークする シークした場合、構造体内部のステートおよびバッファに蓄えているビットは破棄される 参照: dkcMemoryStreamSeek() dkcBit.h の 330 行で定義されています。 参照先 dkcMemoryStreamSeek(), dkc_BitMemoryStream::pms, dkc_BitMemoryStream::read_buff, dkc_BitMemoryStream::read_count, dkc_BitMemoryStream::write_buff, と dkc_BitMemoryStream::write_count. 参照元 init_lzw().
    00331 {
    00332     ptr->read_count =   ptr->read_buff = ptr->write_buff = 0;
    00333
    00334     ptr->write_count = 8;
    00335     return dkcMemoryStreamSeek(ptr->pms,offset,origin);
    00336 }

DKC_INLINE size_t WINAPI dkcBitMemoryStreamTellBit | ( | DKC_BIT_MEMORYSTREAM * | ptr,
|  | size_t * | bit
| ) |

| ビット単位で今のシーク位置（オフセット）を取得する dkcBit.h の 349 行で定義されています。 参照先 dkcBitMemoryStreamTellByte, と dkcmNOT_ASSERT.
    00350 {
    00351     size_t t = dkcBitMemoryStreamTellByte(ptr);
    00352     dkcmNOT_ASSERT(t > UINT_MAX / 8);
    00353     return t * 8;
    00354 }

DKC_INLINE int WINAPI dkcBitMemoryStreamTellBitCheck | ( | DKC_BIT_MEMORYSTREAM * | ptr | ) |

| dkcBit.h の 341 行で定義されています。 参照先 dkcBitMemoryStreamTellByte.
    00341                                                                                {
    00342     size_t t = dkcBitMemoryStreamTellByte(ptr);
    00343     if(t > UINT_MAX / 8){
    00344         return edk_VariableOverFlow;
    00345     }
    00346     return edk_SUCCEEDED;
    00347 }

DKC_INLINE int dkcBitMemoryStreamWrite | ( | DKC_BIT_MEMORYSTREAM * | p,
|  | void * | target_arg,
|  | int | n
| ) |

  | 引数:
  | n[in] | ビット数
dkcBit.h の 152 行で定義されています。 参照先 dkcMemoryStreamDynamicWrite(), dkcMemoryStreamGetSeekPoint(), dkcMemoryStreamSeek(), edkcMemoryStreamSeekSet, dkc_BitMemoryStream::pms, dkc_BitMemoryStream::write_buff, と dkc_BitMemoryStream::write_count. 参照元 encode_hash(), と encode_tst().
    00153 {
    00154     int wc = p->write_count;
    00155     size_t wb = p->write_buff;
    00156     //save point
    00157     size_t sp = dkcMemoryStreamGetSeekPoint(p->pms);
    00158     uint32 *target =(uint32 *) target_arg;
    00159     if( n <= 0 || n >= 32 ) return edk_FAILED;
    00160     while( --n >= 0 ){
    00161         --wc;
    00162 #if DKUTIL_C_USE_BIT_TABLE == 1
    00163         if( dkccvBitTable32[n] & target ){
    00164             wb |= dkccvBitTable8[wc];
    00165         }
    00166 #else
    00167         if( (1<<n) & (*target) ){
    00168             wb |= (1 << wc);//dkccvBitTable8[wc];
    00169         }
    00170 #endif
    00171         if( !wc ){
    00172             if( DKUTIL_FAILED(dkcMemoryStreamDynamicWrite(p->pms, &wb,1 )) )
    00173             {
    00174                 //元の状態に戻す
    00175                 dkcMemoryStreamSeek(p->pms,sp,edkcMemoryStreamSeekSet);
    00176                 return edk_FAILED;
    00177             }
    00178             wc = 8;
    00179             wb = 0;
    00180         }
    00181     }
    00182     /*if( !wc ){
    00183         if( DKUTIL_FAILED(dkcMemoryStreamDynamicWrite(p->pms, &wb,1 )) )
    00184         {
    00185             //元の状態に戻す
    00186             dkcMemoryStreamSeek(p->pms,sp,edkcMemoryStreamSeekSet);
    00187             return edk_FAILED;
    00188         }
    00189         wc = 8;
    00190         wb = 0;
    00191     }*/
    00192     p->write_count = wc;
    00193     p->write_buff = wb;
    00194     return edk_SUCCEEDED;
    00195
    00196 }

DKC_INLINE int dkcBitMemoryStreamWriteLast | ( | DKC_BIT_MEMORYSTREAM * | p | ) |

| dkcBit.h の 198 行で定義されています。 参照先 dkcMemoryStreamDynamicWrite(), dkcMemoryStreamGetSeekPoint(), dkcMemoryStreamSeek(), edkcMemoryStreamSeekSet, dkc_BitMemoryStream::pms, dkc_BitMemoryStream::write_buff, と dkc_BitMemoryStream::write_count. 参照元 encode_hash(), と encode_tst().
    00198                                                                    {
    00199     //return dkcMemoryStreamWrite(p->pms,&p->write_buff,1);
    00200     size_t sp = dkcMemoryStreamGetSeekPoint(p->pms);
    00201     int r = dkcMemoryStreamDynamicWrite(p->pms, &p->write_buff,1 );
    00202     if( DKUTIL_FAILED(r) )
    00203     {
    00204         //元の状態に戻す
    00205         dkcMemoryStreamSeek(p->pms,sp,edkcMemoryStreamSeekSet);
    00206         return r;
    00207     }
    00208     p->write_count = 8;
    00209     p->write_buff = 0;
    00210     return r;
    00211 }

DKC_INLINE int dkcFreeBitMemoryStream | ( | DKC_BIT_MEMORYSTREAM ** | p | ) |

| dkcBit.h の 143 行で定義されています。 参照先 dkcFree(), dkcFreeMemoryStream(), dkcmNOT_ASSERT, と NULL. 参照元 dkcFreeLZW().
    00144 {
    00145     dkcmNOT_ASSERT(NULL==p || NULL==*p || NULL==(*p)->pms);
    00146     dkcFreeMemoryStream(&((*p)->pms));
    00147     return dkcFree((void **)p);
    00148 }

DKC_FORCE_INLINE size_t dkcNLZ | ( | uint32 | x | ) |

| [Henry] p.85 dkcBit.h の 45 行で定義されています。
    00045                                             {/*/dkcNLZ(uint32 x){
    00046     int y,m,n;
    00047
    00048     y = -(int)(x >> 16);
    00049     m = (y >> 16) & 16;
    00050     n = 16 - m;
    00051     x = x >> m;
    00052
    00053     y = x - 0x100;
    00054     m = (y >> 16) & 8;
    00055     n = n + m;
    00056     x = x << m;
    00057
    00058     y = x - 0x1000;
    00059     m = (y >> 16) & 4;
    00060     n = n + m;
    00061     x = x << m;
    00062
    00063     y = x >> 14;
    00064     m = y & ~(y >> 1);
    00065     return n + 2 - m;
    00066 }

DKC_FORCE_INLINE size_t dkcNLZ_IEEE | ( | uint32 | arg | ) |

| これには驚き [Henry] p.86 dkcBit.h の 36 行で定義されています。 参照先 dkc_NLZ8Byte::asDouble_, dkc_NLZ8Byte::asINT_, と dkcdLITTLE_ENDIAN.
    00036                                                {
    00037     union dkc_NLZ8Byte t;
    00038     size_t n;
    00039
    00040     t.asDouble_ = (double)arg + 0.5;
    00041     n = 1054 - (t.asINT_[dkcdLITTLE_ENDIAN] >> 20);
    00042     return n;
    00043 }

DKC_FORCE_INLINE size_t dkcNTZ | ( | uint32 | x | ) |

| number of trailing zeros [Henry] p.90 dkcBit.h の 94 行で定義されています。
    00094                                         {
    00095     return 32 - dkcNTZ(~x&(x-1));
    00096
    00097 }

DKC_FORCE_INLINE size_t dkcPOP | ( | uint32 | x | ) |

  | bitsに入れたビットの数を数える population count 引数:
  | 調べたい32bit変数@note | Hacker's Delight より
dkcBit.h の 74 行で定義されています。
    00074                                                  {
    00075     /*
    00076   bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
    00077   bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
    00078   bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
    00079   bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
    00080   return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
    00081     */
    00082     x = x - ((x >> 1) & 0x55555555);
    00083     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    00084     x = (x + (x >> 4)) & 0x0f0f0f0f;
    00085     x = x + (x >> 8);
    00086     x = x + (x >> 16);
    00087     return x & 0x0000003f;
    00088 }