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

# 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 */