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

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.c22 行で定義されています。

参照先 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.c58 行で定義されています。

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.c751 行で定義されています。

参照先 dkcstd_memchr8().

00751                                                            {
00752     return dkcstd_memchr8( buf,  c,  count );
00753 }

void* dkcstd_memchr8 const void *  buf,
int  c,
size_t  count
 

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

参照先 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.c721 行で定義されています。

参照先 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.c89 行で定義されています。

参照元 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.c702 行で定義されています。

参照先 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.c636 行で定義されています。

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.c676 行で定義されています。

参照先 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.c656 行で定義されています。

参照先 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.c64 行で定義されています。

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.c593 行で定義されています。

参照先 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.c707 行で定義されています。

参照先 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.c80 行で定義されています。

参照元 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.c39 行で定義されています。

参照元 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.c35 行で定義されています。

参照先 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.c10 行で定義されています。

参照元 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 }


dkutil_cstdに対してSat Sep 10 09:19:25 2005に生成されました。  doxygen 1.4.4