メインページ | アルファベット順一覧 | データ構造 | ファイル一覧 | データフィールド | グローバル | 関連ページ

# memory.c

memory.c [詳細]

`#include "memory.h"`
`#include "malloc.h"`

memory.cのインクルード依存関係図

ソースコードを見る。

## マクロ定義
#define | dkcd64BIT_T double
## 関数
DKC_INLINE size_t | dkcstd_size_align (size_t size, size_t align_offset)
void | dkcstd_get_memory_align (DKCSTD_ALIGNED_MEM *r, const void *src, size_t srcsize, size_t align_offset)
DKC_INLINE void * | dkcstd_pointer_align (const void *src, size_t align_offset)
DKC_INLINE size_t | dkcstd_offset_align (const void *src, size_t align_offset)
BOOL | dkcstd_IsAligned (const void *src, size_t bytes)
void * | dkcstd_memcpy8 (void *dest, const void *src, size_t count)
| 8bit毎にコピー
void * | dkcstd_memset8 (void *dest, int c, size_t count)
int | dkcstd_memcmp8 (const void *buf1, const void *buf2, size_t count)
void * | dkcstd_memchr8 (const void *buf, int c, size_t count)
void * | dkcstd_memmove (void *dest, const void *src, size_t count)
void * | dkcstd_memcpy32 (void *dest, const void *src, size_t count)
| 32bit毎にコピー
void * | dkcstd_memcpy64f (void *dest, const void *src, size_t count)
| 64bit毎(double *にキャストして)にコピー
void * | dkcstd_memcpy64 (void *dest, const void *src, size_t count)
| 64bit毎にコピー
void * | dkcstd_memcpy (void *dest, const void *src, size_t count)
| どんな環境でも動く単純なmemcpy()
void * | dkcstd_memset (void *dest, int c, size_t count)
int | dkcstd_memcmp (const void *buf1, const void *buf2, size_t count)
void * | dkcstd_memchr (const void *buf, int c, size_t count)

## 説明

memory.c

作者:
  d金魚

から:
  2005/01/17

memory.c で定義されています。

## マクロ定義

#define dkcd64BIT_T double

| 参照元 dkcstd_memcpy64(), と dkcstd_memcpy64f().

## 関数

void dkcstd_get_memory_align | ( | DKCSTD_ALIGNED_MEM * | r,
|  | const void * | src,
|  | size_t | srcsize,
|  | size_t | align_offset
| ) |

| memory.c の 22 行で定義されています。 参照先 dkcstd_aligned_memory_result::access_permit_from_mem, dkcstd_offset_align(), dkcstd_size_align(), dkcstd_aligned_memory_result::mem, と dkcstd_aligned_memory_result::offset_from_original.
    00023 {
    00024     size_t o = dkcstd_offset_align(src,align_offset);
    00025     BYTE *t = (BYTE *)src;
    00026     size_t m = srcsize - o;
    00027     r->access_permit_from_mem = dkcstd_size_align(m,align_offset);
    00028
    00029     r->mem = t + o;
    00030     r->offset_from_original = o;
    00031 }

BOOL dkcstd_IsAligned | ( | const void * | src,
|  | size_t | bytes
| ) |

| memory.c の 58 行で定義されています。
    00059 {
    00060     size_t force = (size_t)src;
    00061     return (force % bytes == 0);
    00062 }

void* dkcstd_memchr | ( | const void * | buf,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 751 行で定義されています。 参照先 dkcstd_memchr8().
    00751                                                            {
    00752     return dkcstd_memchr8( buf,  c,  count );
    00753 }

void* dkcstd_memchr8 | ( | const void * | buf,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 112 行で定義されています。 参照先 NULL. 参照元 dkcstd_memchr().
    00113 {
    00114     size_t i;
    00115     const uint8 *t = buf,cc = (const uint8)c;
    00116     for(i=0;i<count;i++){
    00117         if(t[i] == cc){
    00118             return (void *)&(t[i]);
    00119         }
    00120     }
    00121     return NULL;
    00122 }

int dkcstd_memcmp | ( | const void * | buf1,
|  | const void * | buf2,
|  | size_t | count
| ) |

| memory.c の 721 行で定義されています。 参照先 dkcstd_memcmp8(). 参照元 dkcstd_bcmp().
    00721                                                                      {
    00722     size_t i;
    00723     const size_t *d,*s;
    00724     size_t cnt = count / sizeof(size_t);
    00725     //size_t mod_ = count - cnt * sizeof(size_t);
    00726     size_t mod_ = count %  sizeof(size_t);
    00727     d = (const size_t *)buf1;
    00728     s = (const size_t *)buf2;
    00729     for(i=0;i<cnt;i++){
    00730         if(d[i] != s[i]){
    00731             /*if(d[i] > s[i]){
    00732                 return d[i] - s[i];
    00733             }else{
    00734                 s[i] - d[i];
    00735             }*/
    00736
    00737             const int *a,*b;
    00738             a = &d[i];
    00739             b = &s[i];
    00740             return *a - *b;
    00741             //return ((int *)&d[i]) - ((int *)&s[i]);
    00742
    00743         }
    00744     }
    00745     cnt = count - mod_;
    00746     return dkcstd_memcmp8(buf1,buf2,count);
    00747 }

int dkcstd_memcmp8 | ( | const void * | buf1,
|  | const void * | buf2,
|  | size_t | count
| ) |

| memory.c の 89 行で定義されています。 参照元 dkcstd_memcmp().
    00089                                                                      {
    00090     const uint8 *a = buf1,*b = buf2;
    00091     size_t i;
    00092     for(i=0;i<count;i++)
    00093     {
    00094         if(a[i] != b[i])
    00095         {
    00096             /*if(a[i] > b[i]){
    00097                 return a[i] - b[i];
    00098             }else{
    00099                 return b[i] - a[i];
    00100             }*/
    00101             const int *aa,*bb;
    00102             aa = (const int *)&a[i];
    00103             bb = (const int *)&b[i];
    00104             return *aa - *bb;
    00105             //return ((int *)&a[i]) - ((int *)&b[i]);
    00106         }
    00107     }
    00108     return 0;
    00109 }

void* dkcstd_memcpy | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| どんな環境でも動く単純なmemcpy() memory.c の 702 行で定義されています。 参照先 dkcstd_memcpy64(). 参照元 dkcstd_bcopy().
    00702                                                                 {
    00703     return dkcstd_memcpy64(dest,src,count);
    00704 }

void* dkcstd_memcpy32 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 32bit毎にコピー memory.c の 636 行で定義されています。
    00636                                                                   {
    00637
    00638     size_t i;
    00639     size_t *d,*s;
    00640     size_t cnt = count / sizeof(size_t);
    00641     //size_t mod_ = count - cnt * sizeof(size_t);
    00642     size_t mod_ = count % sizeof(size_t);//多分、上記よりはイイコードを吐く & 3みたいな？
    00643     d = (size_t *)dest;
    00644     s = (size_t *)src;
    00645     for(i=0;i<cnt;i++){
    00646         d[i] = s[i];
    00647     }
    00648
    00649     cnt = count - mod_;
    00650     for(i=0;i<mod_;i++){
    00651         (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]);
    00652     }
    00653     return dest;
    00654 }

void* dkcstd_memcpy64 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 64bit毎にコピー memory.c の 676 行で定義されています。 参照先 dkcd64BIT_T, と dkcstd_memcpy64f(). 参照元 dkcstd_memcpy().
    00676                                                                   {
    00677 #ifndef WIN32
    00678     return dkcstd_memcpy64f(dest,src,count);
    00679 #else
    00680
    00681 #undef dkcd64BIT_T
    00682 #define dkcd64BIT_T ULONGLONG
    00683     size_t i;
    00684     dkcd64BIT_T *d,*s;
    00685     size_t cnt = count / sizeof(dkcd64BIT_T);
    00686     //size_t mod_ = count - cnt * sizeof(dkcd64BIT_T);
    00687     size_t mod_ = count %  sizeof(dkcd64BIT_T);
    00688     d = (dkcd64BIT_T *)dest;
    00689     s = (dkcd64BIT_T *)src;
    00690     for(i=0;i<cnt;i++){
    00691         d[i] = s[i];
    00692     }
    00693
    00694     cnt = count - mod_;
    00695     for(i=0;i<mod_;i++){
    00696         (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]);
    00697     }
    00698     return dest;
    00699 #endif
    00700 }

void* dkcstd_memcpy64f | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 64bit毎(double *にキャストして)にコピー memory.c の 656 行で定義されています。 参照先 dkcd64BIT_T. 参照元 dkcstd_memcpy64().
    00656                                                                    {
    00657 #define dkcd64BIT_T double
    00658     size_t i;
    00659     dkcd64BIT_T *d,*s;
    00660     size_t cnt = count / sizeof(dkcd64BIT_T);
    00661     //size_t mod_ = count - cnt * sizeof(dkcd64BIT_T);
    00662     size_t mod_ = count %  sizeof(dkcd64BIT_T);
    00663     d = (dkcd64BIT_T *)dest;
    00664     s = (dkcd64BIT_T *)src;
    00665     for(i=0;i<cnt;i++){
    00666         d[i] = s[i];
    00667     }
    00668
    00669     cnt = count - mod_;
    00670     for(i=0;i<mod_;i++){
    00671         (((uint8 *)dest)[cnt + i]) = (((const uint8 *)src)[cnt + i]);
    00672     }
    00673     return dest;
    00674 }

void* dkcstd_memcpy8 | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| 8bit毎にコピー memory.c の 64 行で定義されています。
    00064                                                                  {
    00065     size_t i;
    00066     uint8 *d;
    00067     const uint8 *s;
    00068
    00069     d = dest;
    00070     s = src;
    00071
    00072     for(i=0;i<count;i++){
    00073         d[i] = s[i];
    00074     }
    00075     return dest;
    00076 }

void* dkcstd_memmove | ( | void * | dest,
|  | const void * | src,
|  | size_t | count
| ) |

| TODO: filter部のオーバーフローをチェックする事 TODO: filter部のオーバーフローをチェックする事 memory.c の 593 行で定義されています。 参照先 memcpy, と NULL.
    00593                                                                  {
    00594     uint8 *d = (uint8 *)dest;
    00595   const uint8 *s = (const uint8 *)src;
    00596     size_t i;
    00597
    00598     uint8 *pb;
    00599     //filter
    00600     size_t alloc_offset;
    00601
    00602
    00603     pb = (uint8*)s + count;//ここ、オーバーフロー？
    00604     if((void *)pb > dest){
    00605         alloc_offset = (size_t)(uint8*)(pb - d);
    00606         pb = (uint8*)malloc(alloc_offset);
    00607         //dest は srcの最後の部分と重なっているから･･･。
    00608         memcpy(pb,dest,alloc_offset);
    00609     }else{
    00610         alloc_offset = 0;
    00611         pb = NULL;
    00612     }
    00613
    00614
    00615     //process
    00616     {
    00617         size_t c = count - alloc_offset;
    00618         for(i=0;i<c;i++){
    00619             d[i] = s[i];
    00620         }
    00621         d += i;
    00622         for(i=0;i<alloc_offset;i++){
    00623             d[i] = pb[i];
    00624         }
    00625     }
    00626
    00627
    00628     if(pb){
    00629         free(pb);
    00630     }
    00631     return dest;
    00632 }

void* dkcstd_memset | ( | void * | dest,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 707 行で定義されています。 参照先 dkcstd_memset8(). 参照元 dkcstd_bzero().
    00707                                                       {
    00708     uint8 cc = (uint8)c;
    00709     uint32 ccc = cc | (cc << 8) | (cc << 16) | (cc << 24);
    00710     size_t i;
    00711     size_t cnt = count / sizeof(uint32);// >> 2か？まぁ、最適化頼みって事で
    00712     size_t mod = count % sizeof(uint32);
    00713     size_t *d = dest;
    00714     for(i=0;i<cnt;i++){
    00715         d[i] = ccc;
    00716     }
    00717     dkcstd_memset8(&d[i],c,mod);
    00718     return dest;
    00719 }

void* dkcstd_memset8 | ( | void * | dest,
|  | int | c,
|  | size_t | count
| ) |

| memory.c の 80 行で定義されています。 参照元 dkcstd_memset().
    00080                                                        {
    00081     uint8 cc = (uint8)c;
    00082     size_t i;
    00083     for(i=0;i<count;i++){
    00084         ((uint8 *)dest)[i] = cc;
    00085     }
    00086     return dest;
    00087 }

DKC_INLINE size_t dkcstd_offset_align | ( | const void * | src,
|  | size_t | align_offset
| ) |

| memory.c の 39 行で定義されています。 参照元 dkcstd_get_memory_align(), と dkcstd_pointer_align().
    00039                                                                           {
    00040     size_t force = (size_t)src;
    00041     size_t save = force;
    00042     while((force % align_offset )!= 0){
    00043         force++;
    00044 #ifdef WIN32
    00045         //(確かWin32の場合、0x7FFFFFFFより上の領域は返さないはずだが･･･
    00046         //if(0x7FFFFFFF<=force){
    00047         if(0x80000000 <= force){
    00048             break;
    00049         }
    00050 #else
    00051         if(0==force){//安全策
    00052             break;
    00053         }
    00054 #endif
    00055     }
    00056     return force - save;
    00057 }

DKC_INLINE void* dkcstd_pointer_align | ( | const void * | src,
|  | size_t | align_offset
| ) |

| memory.c の 35 行で定義されています。 参照先 dkcstd_offset_align(). 参照元 aligned_malloc_calc().
    00035                                                                            {
    00036     return ((uint8 *)src) + dkcstd_offset_align(src,align_offset);
    00037 }

DKC_INLINE size_t dkcstd_size_align | ( | size_t | size,
|  | size_t | align_offset
| ) |

| memory.c の 10 行で定義されています。 参照元 dkcstd_get_memory_align().
    00010                                                                     {
    00011     size_t t = size;
    00012     while((t % align_offset )!= 0){
    00013         t--;
    00014         if(0==t){
    00015             break;
    00016         }
    00017     }
    00018     return t;
    00019 }