00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068 #include "mfifo.h"
00069 #include <memory.h>
00070 #include <stdlib.h>
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085 int MFIFOCreate(unsigned char *buf, int size, int index)
00086 {
00087 MFIFO *mf = (MFIFO *)buf;
00088
00089 mf->first = mf->last = 0;
00090 mf->ixsize = index;
00091 mf->buf = &buf[sizeof(MFIFO) + (sizeof(MINDEX) * index)];
00092
00093 if (mf->buf > &buf[size])
00094 return 0;
00095
00096 mf->bsize = size - sizeof(MFIFO) - (sizeof(MINDEX) * index);
00097
00098 return 1;
00099 }
00100
00101
00102
00103
00104
00105
00106
00107
00108
00109
00110
00111
00112 void MFIFOClear(unsigned char * buf)
00113 {
00114 MFIFO *mf = (MFIFO *)buf;
00115
00116 mf->first = mf->last = 0;
00117 }
00118
00119
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130 int MFIFOGetLBOffset(unsigned char *buf)
00131 {
00132 MFIFO *mf = (MFIFO *)buf;
00133
00134 if (mf->last != mf->first)
00135 return mf->ix[mf->last].offset;
00136
00137 return 0;
00138 }
00139
00140
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151
00152
00153 int MFIFOGetFBOffset(unsigned char *buf)
00154 {
00155 MFIFO *mf = (MFIFO *)buf;
00156 int x;
00157
00158 if (mf->last == mf->first)
00159 return 0;
00160
00161 x = mf->first - 1;
00162
00163 if (x < 0)
00164 x = mf->ixsize - 1;
00165
00166 return mf->ix[x].offset + mf->ix[x].size;
00167 }
00168
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186 void MFIFOWriteIX(unsigned char *buf, unsigned char *mes, int size, int ix, int off)
00187 {
00188 MFIFO *mf = (MFIFO *)buf;
00189 int x;
00190
00191 memcpy(&mf->buf[off], mes, size);
00192 mf->ix[ix].offset = off;
00193 mf->ix[ix].size = size;
00194
00195 x = mf->first + 1;
00196
00197 if (x >= mf->ixsize)
00198 x = 0;
00199
00200 mf->first = x;
00201 }
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214 int MFIFOWriteMes(unsigned char *buf, unsigned char *mes, int size)
00215 {
00216 MFIFO *mf = (MFIFO *)buf;
00217 int of, ol, x;
00218
00219 x = mf->first + 1;
00220
00221 if (x >= mf->ixsize)
00222 x = 0;
00223
00224 if (x == mf->last)
00225 return 0;
00226
00227 of = MFIFOGetFBOffset(buf);
00228 ol = MFIFOGetLBOffset(buf);
00229 if (mf->last == mf->first) {
00230 mf->first = mf->last = 0;
00231
00232 MFIFOWriteIX(buf, mes, size, mf->first, 0);
00233 return 1;
00234 }
00235 else if (of > ol) {
00236 if (mf->bsize - of >= size) {
00237 MFIFOWriteIX(buf, mes, size, mf->first, of);
00238 return 1;
00239 }
00240 else if (ol > size) {
00241 MFIFOWriteIX(buf, mes, size, mf->first, ol);
00242 return 1;
00243 }
00244 }
00245 else if (ol - of > size) {
00246 MFIFOWriteIX(buf, mes, size, mf->first, of);
00247 return 1;
00248 }
00249
00250 return 0;
00251 }
00252
00253
00254
00255
00256
00257
00258
00259
00260
00261
00262
00263
00264 unsigned char * MFIFOGetMesPtr(unsigned char *buf, int *size)
00265 {
00266 MFIFO *mf = (MFIFO *)buf;
00267
00268 if (mf->first == mf->last) {
00269 return NULL;
00270 }
00271
00272 *size = mf->ix[mf->last].size;
00273 return &mf->buf[mf->ix[mf->last].offset];
00274 }
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284
00285
00286
00287 void MFIFOKillNext(unsigned char *buf)
00288 {
00289 MFIFO *mf = (MFIFO *)buf;
00290 int x;
00291
00292 if (mf->first != mf->last) {
00293 x = mf->last + 1;
00294 if (x >= mf->ixsize) {
00295 x = 0;
00296 }
00297
00298 mf->last = x;
00299 }
00300 }
00301
00302
00303
00304
00305
00306
00311 unsigned char * MFIFOGetMesPtrOffset(unsigned char *buf, int *size, const int pos)
00312 {
00313 MFIFO *mf = (MFIFO *)buf;
00314 int x;
00315
00316 if (mf->first == mf->last) {
00317 return NULL;
00318 }
00319
00320 if (pos < 0 || pos >= mf->ixsize) {
00321 return NULL;
00322 }
00323
00324 x = pos - mf->last;
00325 if (x < 0) {
00326 x += (mf->ixsize - 1);
00327 }
00328
00329 *size = mf->ix[x].size;
00330 return &mf->buf[mf->ix[x].offset];
00331 }
00332
00333
00338 int MFIFOGetMesCount(unsigned char *buf)
00339 {
00340 MFIFO *mf = (MFIFO *)buf;
00341
00342 if (mf->first == mf->last) {
00343 return 0;
00344 }
00345 else if (mf->first > mf->last) {
00346 return mf->first - mf->last;
00347 }
00348 else {
00349 return (mf->ixsize - mf->last) + mf->first;
00350 }
00351 }
00352
00357 int MFIFOWriteMesOverwrite(unsigned char *buf, unsigned char *mes, int size)
00358 {
00359 MFIFO *mf = (MFIFO *)buf;
00360 int of, ol, x;
00361
00362 x = mf->first + 1;
00363
00364 if (x >= mf->ixsize)
00365 x = 0;
00366
00367 if (x == mf->last) {
00368
00369 mf->last++;
00370
00371 if (mf->last >= mf->ixsize)
00372 mf->last = 0;
00373 }
00374
00375 of = MFIFOGetFBOffset(buf);
00376 ol = MFIFOGetLBOffset(buf);
00377
00378 if (mf->last == mf->first) {
00379 mf->first = mf->last = 0;
00380
00381 MFIFOWriteIX(buf, mes, size, mf->first, 0);
00382 return 1;
00383 }
00384 else if (of > ol) {
00385 if (mf->bsize - of >= size) {
00386 MFIFOWriteIX(buf, mes, size, mf->first, of);
00387 return 1;
00388 }
00389 else if (ol > size) {
00390 MFIFOWriteIX(buf, mes, size, mf->first, ol);
00391 return 1;
00392 }
00393 }
00394 else if (ol - of > size) {
00395 MFIFOWriteIX(buf, mes, size, mf->first, of);
00396 return 1;
00397 }
00398 return 0;
00399 }