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

dkcStack.c

説明を見る。
00001 
00007 #define DKUTIL_C_STACK_C
00008 #include "dkcStack.h"
00009 #include "dkcStdio.h"
00010 
00011 
00012 DKC_STACK * WINAPI dkcAllocStack(size_t numof__,size_t offsetof__){
00013     DKC_STACK *p;
00014     size_t size = numof__ * offsetof__;
00015     if(0==size) return NULL;
00016     p = (DKC_STACK *)dkcAllocate(sizeof(DKC_STACK));
00017     if(NULL==p) return NULL;
00018     p->mBuffer = (BYTE *)dkcAllocate(size);
00019     
00020     if(NULL==p->mBuffer) goto Error;
00021 
00022     p->mCount = 0;
00023     p->mSize = size;
00024     p->mOffsetOf = offsetof__;
00025 
00026     return p;
00027 Error:
00028     dkcFree((void **)&p);
00029     return NULL;
00030 }
00031 
00032 int WINAPI dkcFreeStack(DKC_STACK **ptr){
00033     if(NULL==ptr || *ptr==NULL || NULL==(*ptr)->mBuffer)
00034         return edk_ArgumentException;
00035 
00036     dkcFree((void **)&((*ptr)->mBuffer));
00037     return dkcFree((void **)ptr);
00038 }
00039 
00040 void WINAPI dkcStackPop(DKC_STACK *ptr){
00041     dkcmNOT_ASSERT(NULL==ptr);
00042     
00043     //もう無い判定
00044     if(ptr->mCount <= 0){
00045         return ;
00046     }
00047 
00048     ptr->mCount --;
00049 
00050     return;
00051 }
00052 
00053 int WINAPI dkcStackTop(DKC_STACK *ptr,void *get_data)
00054 {
00055 
00056     BYTE *tp;
00057     size_t point;
00058     dkcmNOT_ASSERT(NULL==ptr);
00059     
00060     point = ptr->mOffsetOf * (ptr->mCount-1);//mCountの-1の所のアドレスに存在するデータだから・・・。
00061 
00062     //もう無い判定
00063     if(ptr->mCount <= 0){
00064         return edk_FAILED;
00065     }
00066 
00067 
00068     tp = ptr->mBuffer;
00069     
00070     memcpy(get_data,&tp[point],ptr->mOffsetOf);
00071 
00072     //ptr->mCount --;
00073 
00074     return edk_SUCCEEDED;
00075 
00076 }
00077 
00078 int WINAPI dkcStackPush(DKC_STACK *ptr,const void *data)
00079 {
00080     BYTE *tp;
00081     size_t point;
00082     dkcmNOT_ASSERT(NULL==ptr);
00083 
00084     point = ptr->mCount * ptr->mOffsetOf;
00085     //もう限界判定
00086     if(ptr->mSize <= point ){
00087         return edk_FAILED;
00088     }
00089     tp = ptr->mBuffer;
00090 
00091     memcpy(&tp[point],data,ptr->mOffsetOf);
00092 
00093     ptr->mCount ++;
00094 
00095     return edk_SUCCEEDED;
00096 
00097 }
00098 
00099 int WINAPI dkcStackDynamicPush(DKC_STACK *ptr,const void *data)
00100 {
00101     BYTE *tp;
00102     size_t point;
00103 
00104     void *NewPtr;
00105     size_t want_size;
00106     dkcmNOT_ASSERT(NULL==ptr);
00107 
00108     point = ptr->mCount * ptr->mOffsetOf;
00109 
00110     //もう限界判定
00111     if(ptr->mSize <= point ){
00112         //メモリ再確保
00113         want_size = dkcReallocateSizeFunction(ptr->mSize,ptr->mOffsetOf);
00114         if(DKUTIL_FAILED(
00115             dkcReallocate(&NewPtr,want_size,(void **)&ptr->mBuffer)
00116             )){
00117             return edk_FAILED;
00118         }
00119         ptr->mBuffer = (BYTE *)NewPtr;
00120         ptr->mSize = want_size;
00121 
00122     }
00123     tp = ptr->mBuffer;
00124 
00125     memcpy(&tp[point],data,ptr->mOffsetOf);
00126 
00127     ptr->mCount ++;
00128 
00129     return edk_SUCCEEDED;
00130 
00131 
00132 }
00133 void WINAPI dkcStackClear(DKC_STACK *ptr){
00134     //memset(ptr->mBuffer,0,ptr->mSize);
00135     ptr->mCount = 0;
00136 }
00137 
00138 size_t WINAPI dkcStackSize(DKC_STACK *ptr){
00139     return ptr->mCount;
00140 }
00141 
00142 BOOL WINAPI dkcStackIsEmpty(DKC_STACK *ptr){
00143     return (dkcStackSize(ptr)==0);
00144 }
00145 
00146 DKC_INLINE size_t WINAPI dkcStackCapacity(DKC_STACK *ptr){
00147     return (ptr->mSize / ptr->mOffsetOf);
00148 }
00149 
00150 DKC_INLINE size_t WINAPI dkcStackRestSize(DKC_STACK *ptr){
00151     return dkcStackCapacity(ptr) - dkcStackSize(ptr);
00152 }
00153 /*
00154 int WINAPI dkcStackSerialize(const DKC_STACK *ptr,DKC_SERIALIZE *se)
00155 {
00156     int id = edkcSerializeIDStack;
00157     dkcmNOT_ASSERT(NULL==ptr);
00158     dkcSerializeWrite(se,&id,sizeof(id));
00159     dkcSerializeWrite(se,ptr,sizeof(DKC_STACK));
00160     return dkcSerializeWrite(se,ptr->mBuffer,ptr->mSize);
00161 }
00162 
00163 DKC_STACK* WINAPI dkcAllocStackDeserialize(DKC_DESERIALIZE *se)
00164 {
00165     DKC_STACK *p;
00166     DKC_STACK t;
00167     size_t read;
00168     int id;
00169     
00170     dkcDeserializeRead(se,&id,sizeof(id),&read);
00171     if(id !=  edkcSerializeIDStack)
00172     {
00173         return NULL;
00174     }
00175     dkcDeserializeRead(se,&t,sizeof(t),&read);
00176     
00177     p = dkcAllocStack(t.mSize,t.mOffsetOf);
00178     if(NULL==p) return NULL;
00179 
00180 
00181     dkcDeserializeRead(se,p->mBuffer,p->mSize,&read);
00182     p->mCount = t.mCount;
00183     p->mOffsetOf = t.mOffsetOf;
00184 
00185 
00186     dkcmNOT_ASSERT(read != p->mSize);
00187     
00188     return p;
00189 }
00190 */
00191 DKC_INLINE void *WINAPI dkcStackPointer(DKC_STACK *ptr){
00192     return ptr->mBuffer;
00193 }
00194 
00195 
00196 /*
00197 DKC_STACK * WINAPI dkcAllocStack(size_t numof__,size_t offsetof__){
00198     DKC_STACK *p;
00199     size_t size = numof__ * offsetof__;
00200     if(0==size) return NULL;
00201     p = dkcAllocate(sizeof(DKC_STACK));
00202     if(NULL==p) return NULL;
00203     p->mBuffer = dkcAllocate(size);
00204     
00205     if(NULL==p->mBuffer) goto Error;
00206 
00207     p->mCount = 0;
00208     p->mSize = size;
00209     p->mOffsetOf = offsetof__;
00210 
00211     return p;
00212 Error:
00213     dkcFree((void **)&p);
00214     return NULL;
00215 }
00216 
00217 int WINAPI dkcFreeStack(DKC_STACK **ptr){
00218     if(NULL==ptr || *ptr==NULL || NULL==(*ptr)->mBuffer)
00219         return edk_ArgumentException;
00220 
00221     dkcFree((void **)&((*ptr)->mBuffer));
00222     return dkcFree((void **)ptr);
00223 }
00224 
00225 int WINAPI dkcPopStack(DKC_STACK *ptr,void *get_data){
00226     BYTE *tp;
00227     dkcmNOT_ASSERT(NULL==ptr);
00228     
00229     //もう無い判定
00230     if(ptr->mOffsetOf > ptr->mCount){
00231         return edk_FAILED;
00232         }
00233 
00234     tp = ptr->mBuffer;
00235     
00236     memcpy(get_data,&tp[ptr->mCount - ptr->mOffsetOf],ptr->mOffsetOf);
00237 
00238     ptr->mCount -= ptr->mOffsetOf;
00239 
00240     return edk_SUCCEEDED;
00241 }
00242 
00243 int WINAPI dkcPushStack(DKC_STACK *ptr,const void *data)
00244 {
00245     BYTE *tp;
00246     dkcmNOT_ASSERT(NULL==ptr);
00247     //もう限界判定
00248     if(ptr->mSize < ptr->mCount + ptr->mOffsetOf){
00249         return edk_FAILED;
00250     }
00251     tp = ptr->mBuffer;
00252 
00253     memcpy(&tp[ptr->mCount],data,ptr->mOffsetOf);
00254 
00255     ptr->mCount += ptr->mOffsetOf;
00256 
00257     return edk_SUCCEEDED;
00258 
00259 }
00260 
00261 void WINAPI dkcStackClear(DKC_STACK *ptr){
00262     //memset(ptr->mBuffer,0,ptr->mSize);
00263     ptr->mCount = 0;
00264 }
00265 */

dkutil_cに対してSat Sep 10 09:23:57 2005に生成されました。  doxygen 1.4.4