00001
00011 #include "buffer.h"
00012 #include "jbxl_state.h"
00013
00014
00024 Buffer* new_Buffer(int sz)
00025 {
00026 Buffer* buf;
00027
00028 buf = (Buffer*)malloc(sizeof(Buffer));
00029 if (buf==NULL) return NULL;
00030
00031 memset(buf, 0, sizeof(Buffer));
00032 buf->vldsz = -1;
00033 buf->state = JBXL_NORMAL;
00034
00035 if (sz>0) *buf = make_Buffer(sz + 1);
00036 return buf;
00037 }
00038
00039
00040
00049 Buffer init_Buffer()
00050 {
00051 Buffer buf;
00052
00053 memset(&buf, 0, sizeof(Buffer));
00054 buf.vldsz = -1;
00055 buf.state = JBXL_NORMAL;
00056
00057 return buf;
00058 }
00059
00060
00061
00074 Buffer make_Buffer(int sz)
00075 {
00076 Buffer buf;
00077
00078 memset(&buf, 0, sizeof(Buffer));
00079 buf.state = JBXL_NORMAL;
00080 if (sz<0) return buf;
00081
00082 buf.bufsz = sz;
00083 buf.buf = (unsigned char*)malloc(buf.bufsz+1);
00084
00085 if (buf.buf==NULL) {
00086 buf.bufsz = 0;
00087 buf.vldsz = -1;
00088 buf.state = JBXL_ERROR;
00089 }
00090 else {
00091 memset(buf.buf, 0, buf.bufsz+1);
00092 }
00093
00094 return buf;
00095 }
00096
00097
00098
00112 Buffer make_Buffer_bychar(unsigned char cc)
00113 {
00114 Buffer buf;
00115
00116 buf = make_Buffer(LADDR);
00117 if (buf.buf==NULL) return buf;
00118
00119 buf.buf[0] = cc;
00120 buf.vldsz = 1;
00121 return buf;
00122 }
00123
00124
00125
00133 void free_Buffer(Buffer* buf)
00134 {
00135 if (buf!=NULL) {
00136 if (buf->buf!=NULL) free(buf->buf);
00137 buf->buf = NULL;
00138 memset(buf, 0, sizeof(Buffer));
00139 buf->vldsz = -1;
00140 buf->state = JBXL_NORMAL;
00141 }
00142 }
00143
00144
00145
00154 void del_Buffer(Buffer** buf)
00155 {
00156 if (buf!=NULL && *buf!=NULL) {
00157 if ((*buf)->buf!=NULL) free((*buf)->buf);
00158 (*buf)->buf = NULL;
00159 free(*buf);
00160 *buf = NULL;
00161 }
00162 }
00163
00164
00165
00177 Buffer set_Buffer(void* dat, int len)
00178 {
00179 Buffer buf;
00180
00181 buf = init_Buffer();
00182 if (dat==NULL) return buf;
00183
00184 if (len<0) len = (int)strlen((char*)dat);
00185 buf = make_Buffer(len);
00186 if (buf.buf==NULL) return buf;
00187
00188 memcpy(buf.buf, dat, len);
00189 buf.vldsz = len;
00190 return buf;
00191 }
00192
00193
00199 Buffer make_Buffer_randomstr(int n)
00200 {
00201 char* str = random_str(n);
00202
00203 Buffer buf = set_Buffer(str, -1);
00204 free(str);
00205
00206 return buf;
00207 }
00208
00209
00210
00219 Buffer dup_Buffer(Buffer buf)
00220 {
00221 Buffer str = buf;
00222
00223 if (buf.bufsz>=0 && buf.buf!=NULL) {
00224 str.buf = (unsigned char*)malloc(buf.bufsz+1);
00225 memcpy(str.buf, buf.buf, buf.bufsz);
00226 str.buf[buf.bufsz] = '\0';
00227 }
00228
00229 return str;
00230 }
00231
00232
00233
00243 Buffer rept_Buffer(unsigned char cc, int n)
00244 {
00245 int i;
00246 Buffer str;
00247
00248 if (n<=0) n = 1;
00249 str = make_Buffer(n);
00250 for (i=0; i<n; i++) str.buf[i] = cc;
00251 str.vldsz = n;
00252 return str;
00253 }
00254
00255
00256
00263 void expand_Buffer(Buffer* buf, int len)
00264 {
00265 if (buf->bufsz>len) return;
00266
00267 Buffer expand = make_Buffer(len);
00268 copy_Buffer(buf, &expand);
00269 free_Buffer(buf);
00270
00271 *buf = expand;
00272 }
00273
00274
00275
00283 void clear_Buffer(Buffer* str)
00284 {
00285 if (str->buf!=NULL) memset(str->buf, 0, str->bufsz+1);
00286 str->vldsz = 0;
00287 str->state = JBXL_NORMAL;
00288 }
00289
00290
00291
00327 int copy_Buffer(Buffer* src, Buffer* dst)
00328 {
00329 int sz, dz;
00330
00331 if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
00332 if (src->buf==NULL) return JBXL_NULL_ERROR;
00333
00334 sz = src->vldsz;
00335 if (sz<0) sz = (int)strlen((const char*)src->buf);
00336 if (sz==0) return 0;
00337
00338 if (dst->bufsz < sz) {
00339 unsigned char* buf;
00340
00341 dz = (int)((sz+1)*BUFFER_FACT);
00342 buf = (unsigned char*)malloc(dz+1);
00343 if (buf==NULL) return JBXL_MALLOC_ERROR;
00344
00345 free(dst->buf);
00346 dst->bufsz = dz;
00347 dst->buf = buf;
00348 }
00349
00350
00351 memcpy(dst->buf, src->buf, sz);
00352 dst->buf[sz] = '\0';
00353 dst->vldsz = sz;
00354
00355 return sz;
00356 }
00357
00358
00359
00396 int cat_Buffer(Buffer* src, Buffer* dst)
00397 {
00398 int sz, dz;
00399
00400 if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
00401 if (src->buf==NULL) return JBXL_NULL_ERROR;
00402
00403 sz = src->vldsz;
00404 if (sz<0) sz = (int)strlen((const char*)src->buf);
00405 if (sz==0) return 0;
00406
00407 dz = dst->vldsz;
00408 if (dz<0) {
00409 if (dst->buf!=NULL) dz = (int)strlen((const char*)dst->buf);
00410 else dz = 0;
00411 }
00412
00413 if (dst->bufsz < sz+dz) {
00414 Buffer buf;
00415 buf.state = dst->state;
00416 buf.bufsz = (int)((dst->bufsz+sz+1)*BUFFER_FACT);
00417 buf.vldsz = dz;
00418 buf.buf = (unsigned char*)malloc(buf.bufsz+1);
00419 if (buf.buf==NULL) return JBXL_MALLOC_ERROR;
00420
00421 memcpy(buf.buf, dst->buf, dz);
00422 buf.buf[dz] = '\0';
00423 free_Buffer(dst);
00424 *dst = buf;
00425
00426
00427
00428
00429
00430
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440
00441
00442
00443
00444
00445
00446
00447 }
00448
00449
00450 memcpy(dst->buf+dz, src->buf, sz);
00451 dst->buf[dz+sz] = '\0';
00452 dst->vldsz = sz + dz;
00453
00454 return dst->vldsz;
00455 }
00456
00457
00458
00471 int ins_Buffer(Buffer* src, Buffer* dst)
00472 {
00473 Buffer tmp = make_Buffer(src->bufsz + dst->bufsz);
00474
00475 int ret = copy_Buffer(src, &tmp);
00476 if (ret<0) {
00477 free_Buffer(&tmp);
00478 return ret;
00479 }
00480
00481 ret = cat_Buffer(dst, &tmp);
00482 if (ret<0) {
00483 free_Buffer(&tmp);
00484 return ret;
00485 }
00486
00487 free_Buffer(dst);
00488 *dst = tmp;
00489
00490 return dst->vldsz;
00491 }
00492
00493
00494
00532 int copy_b2Buffer(void* src, Buffer* dst, int len)
00533 {
00534 int sz, dz;
00535
00536 if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
00537 if (len<0) sz = (int)strlen((const char*)src);
00538 else sz = len;
00539 if (sz<=0) return 0;
00540
00541 if (dst->bufsz < sz) {
00542 unsigned char* buf;
00543 dz = (int)((sz+1)*BUFFER_FACT);
00544 buf = (unsigned char*)malloc(dz+1);
00545 if (buf==NULL) return JBXL_MALLOC_ERROR;
00546 if (dst->buf!=NULL) free(dst->buf);
00547 dst->bufsz = dz;
00548 dst->buf = buf;
00549 }
00550
00551 memcpy(dst->buf, src, sz);
00552 dst->buf[sz] = '\0';
00553 dst->vldsz = sz;
00554 dst->state = JBXL_NORMAL;
00555
00556 return sz;
00557 }
00558
00559
00560
00598 int cat_b2Buffer(void* src, Buffer* dst, int len)
00599 {
00600 int sz, dz;
00601
00602 if (src==NULL || dst==NULL) return JBXL_NULL_ERROR;
00603 if (len<0) sz = (int)strlen((const char*)src);
00604 else sz = len;
00605 if (sz<=0) return 0;
00606
00607 dz = dst->vldsz;
00608 if (dz<0) {
00609 if (dst->buf!=NULL) dz = (int)strlen((const char*)dst->buf);
00610 else dz = 0;
00611 }
00612
00613 if (dst->bufsz < sz+dz) {
00614 Buffer buf;
00615 buf.state = dst->state;
00616 buf.bufsz = (int)((dst->bufsz+sz+1)*BUFFER_FACT);
00617 buf.vldsz = dz;
00618 buf.buf = (unsigned char*)malloc(buf.bufsz+1);
00619 if (buf.buf==NULL) return JBXL_MALLOC_ERROR;
00620
00621 memcpy(buf.buf, dst->buf, dz);
00622 buf.buf[dz] = '\0';
00623 free_Buffer(dst);
00624 *dst = buf;
00625 }
00626
00627 memcpy(dst->buf+dz, src, sz);
00628 dst->buf[dz+sz] = '\0';
00629 dst->vldsz = sz + dz;
00630
00631 return dst->vldsz;
00632 }
00633
00634
00635
00650 int ins_b2Buffer(void* src, Buffer* dst, int len)
00651 {
00652 Buffer tmp = make_Buffer(dst->bufsz+len);
00653
00654 int ret = copy_b2Buffer(src, &tmp, len);
00655 if (ret<0) {
00656 free_Buffer(&tmp);
00657 return ret;
00658 }
00659
00660 ret = cat_Buffer(dst, &tmp);
00661 if (ret<0) {
00662 free_Buffer(&tmp);
00663 return ret;
00664 }
00665
00666 free_Buffer(dst);
00667 *dst = tmp;
00668
00669 return dst->vldsz;
00670 }
00671
00672
00673
00679 int copy_i2Buffer(int src, Buffer* dst)
00680 {
00681 char num[LEN_INT];
00682
00683 snprintf(num, LEN_INT-1, "%d", src);
00684 return copy_b2Buffer((void*)num, dst, (int)strlen(num));
00685 }
00686
00687
00688
00694 int cat_i2Buffer(int src, Buffer* dst)
00695 {
00696 char num[LEN_INT];
00697
00698 snprintf(num, LEN_INT-1, "%d", src);
00699 return cat_b2Buffer((void*)num, dst, (int)strlen(num));
00700 }
00701
00702
00703
00709 int ins_i2Buffer(int src, Buffer* dst)
00710 {
00711 char num[LEN_INT];
00712
00713 snprintf(num, LEN_INT-1, "%d", src);
00714 return ins_b2Buffer((void*)num, dst, (int)strlen(num));
00715 }
00716
00717
00718
00738 int cmp_Buffer(Buffer src, Buffer dst, int n)
00739 {
00740 int i;
00741
00742 if (src.buf==NULL || dst.buf==NULL) return JBXL_NULL_ERROR;
00743 if (n>src.vldsz || n>dst.vldsz) return JBXL_BUFFER_CMP_ERROR;
00744
00745 if (n<=0) {
00746 if (src.vldsz!=dst.vldsz) return 1;
00747 else n = src.vldsz;
00748 }
00749
00750 for (i=0; i<n; i++) {
00751 if (src.buf[i]!=dst.buf[i]) return 1;
00752 }
00753 return 0;
00754 }
00755
00756
00757
00781 Buffer encode_base64_Buffer(Buffer buf)
00782 {
00783 unsigned char* bas;
00784 int sz;
00785 Buffer ecd = init_Buffer();
00786
00787
00788 if (buf.buf==NULL) return ecd;
00789 if (buf.vldsz<0) sz = (int)strlen((const char*)buf.buf);
00790 else sz = buf.vldsz;
00791 if (sz<=0) return ecd;
00792
00793 bas = encode_base64(buf.buf, sz);
00794 if (bas==NULL) return ecd;
00795
00796 sz = ((sz + 2)/3)*4 + 1;
00797 ecd = make_Buffer(sz);
00798 if (ecd.buf==NULL) {
00799 free(bas);
00800 return ecd;
00801 }
00802
00803 copy_s2Buffer((char*)bas, &ecd);
00804
00805 free(bas);
00806 return ecd;
00807 }
00808
00809
00810
00828 Buffer decode_base64_Buffer(Buffer str)
00829 {
00830 unsigned char* bas;
00831 int sz;
00832 Buffer dcd = init_Buffer();
00833
00834 if (str.buf==NULL) return dcd;
00835
00836 bas = decode_base64(str.buf, &sz);
00837 if (bas==NULL) return dcd;
00838
00839 dcd = make_Buffer(sz);
00840 if (dcd.buf==NULL) {
00841 free(bas);
00842 return dcd;
00843 }
00844
00845 copy_b2Buffer(bas, &dcd, sz);
00846 dcd.vldsz = sz;
00847
00848 free(bas);
00849 return dcd;
00850 }
00851
00852
00853
00859 Buffer encode_base64_filename_Buffer(Buffer buf)
00860 {
00861 Buffer enc = encode_base64_Buffer(buf);
00862
00863 int i;
00864 for (i=0; i<enc.vldsz; i++) {
00865 if (enc.buf[i]=='/') enc.buf[i] = '$';
00866 }
00867
00868 return enc;
00869 }
00870
00871
00877 Buffer decode_base64_filename_Buffer(Buffer str)
00878 {
00879 int i;
00880 for (i=0; i<str.vldsz; i++) {
00881 if (str.buf[i]=='$') str.buf[i] = '/';
00882 }
00883
00884 Buffer dec = decode_base64_Buffer(str);
00885
00886 return dec;
00887 }
00888
00889
00890
00903 Buffer get_line_Buffer(Buffer str, int n)
00904 {
00905 int i, j, pos, cnt;
00906 unsigned char* buf;
00907
00908 Buffer ret = init_Buffer();
00909 if (str.buf==NULL) return ret;
00910
00911 buf = str.buf;
00912 for(i=0,j=0; j<n-1; j++) {
00913 while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
00914 while (buf[i]==CHAR_LF || buf[i]==CHAR_CR) i++;
00915 }
00916 if (buf[i]=='\0') return ret;
00917
00918 pos = i;
00919 while (buf[i]!=CHAR_LF && buf[i]!=CHAR_CR && buf[i]!='\0') i++;
00920 cnt = i - pos;
00921
00922 if (cnt>=0) {
00923 ret = make_Buffer(cnt+1);
00924 if (ret.buf==NULL) return str;
00925
00926 for(i=0; i<cnt; i++) ret.buf[i] = buf[pos+i];
00927 ret.buf[cnt] = '\0';
00928 }
00929
00930 ret.vldsz = (int)strlen((const char*)ret.buf);
00931
00932 return ret;
00933 }
00934
00935
00936
00951 Buffer get_seq_data_Buffer(Buffer str, int* ptr)
00952 {
00953 int i, pos, cnt;
00954 unsigned char* buf;
00955
00956 Buffer ret = init_Buffer();
00957
00958 if (str.buf==NULL) return ret;
00959 if (str.vldsz<=0) str.vldsz = (int)strlen((const char*)str.buf);
00960 if (*ptr >= str.vldsz) return ret;
00961
00962 buf = str.buf;
00963 pos = *ptr;
00964 while (buf[*ptr]!=CHAR_LF && buf[*ptr]!=CHAR_CR && buf[*ptr]!='\0') (*ptr)++;
00965 cnt = *ptr - pos;
00966
00967 if (cnt>=0) {
00968 ret = make_Buffer(cnt+1);
00969 if (ret.buf==NULL) return ret;
00970
00971 for(i=0; i<cnt; i++) ret.buf[i] = buf[pos+i];
00972 ret.buf[cnt] = '\0';
00973 }
00974
00975 ret.vldsz = (int)strlen((const char*)ret.buf);
00976
00977
00978 while (buf[*ptr]==CHAR_LF || buf[*ptr]==CHAR_CR) (*ptr)++;
00979
00980 return ret;
00981 }
00982
00983
00984
00999 Buffer awk_Buffer(Buffer str, char cc, int n)
01000 {
01001 int i, j, pos, cnt;
01002 unsigned char* buf = str.buf;
01003 Buffer item = init_Buffer();
01004
01005 if (buf==NULL) return item;
01006 if (n<=0) n = 1;
01007
01008 for(i=0,j=0; j<n-1; j++) {
01009 while (buf[i]!='\0' && buf[i]!=cc) i++;
01010 if (buf[i]==cc) i++;
01011 }
01012 if (buf[i]=='\0') return item;
01013
01014 pos = i;
01015 while (buf[i]!='\0' && buf[i]!=cc) i++;
01016 cnt = i - pos;
01017
01018 item = make_Buffer(cnt);
01019 if (item.buf==NULL) return item;
01020
01021 for (i=0; i<cnt; i++) item.buf[i] = buf[pos+i];
01022 item.vldsz = (int)strlen((const char*)item.buf);
01023
01024 return item;
01025 }
01026
01027
01028
01044 Buffer cawk_Buffer(Buffer str, char cc, int n)
01045 {
01046 int i, j, pos, cnt;
01047 unsigned char* buf = str.buf;
01048 Buffer item = init_Buffer();
01049
01050 if (buf==NULL) return item;
01051 if (n<=0) n = 1;
01052
01053 i = 0;
01054 for(j=0; j<n-1; j++) {
01055 while (buf[i]!='\0' && buf[i]!=cc) i++;
01056 while (buf[i]!='\0' && buf[i]==cc) i++;
01057 }
01058 if (buf[i]=='\0') return item;
01059
01060 pos = i;
01061 while (buf[i]!='\0' && buf[i]!=cc) i++;
01062 cnt = i - pos;
01063
01064 item = make_Buffer(cnt);
01065 if (item.buf==NULL) return item;
01066
01067 for (i=0; i<cnt; i++) item.buf[i] = buf[pos+i];
01068 item.vldsz = (int)strlen((const char*)item.buf);
01069
01070 return item;
01071 }
01072
01073
01074
01085 Buffer pack_Buffer(Buffer buf, char cc)
01086 {
01087 Buffer res = init_Buffer();
01088
01089 if (buf.buf==NULL) return res;
01090
01091 res.buf = (unsigned char*)pack_char((char*)buf.buf, cc);
01092 res.vldsz = (int)strlen((char*)res.buf);
01093 res.bufsz = res.vldsz;
01094
01095 return res;
01096 }
01097
01098
01099
01109 void kanji_convert_Buffer(Buffer* str)
01110 {
01111 int i;
01112 unsigned char *c1, *c2;
01113
01114 if (KanjiCode==CODE_SJIS) {
01115 i = 0;
01116 while(str->buf[i]!='\0'){
01117 c1 = &(str->buf[i]);
01118 c2 = c1 + 1;
01119 if(*c1>=0xa1 && *c1<=0xfe){
01120 euc2sjis(c1, c2);
01121 i = i + 2;
01122 }
01123 else i++;
01124 }
01125 }
01126
01127
01128
01129
01130
01131
01132
01133
01134
01135
01136
01137
01138
01139
01140 }
01141
01142
01143
01152 Buffer randstr_Buffer(int n)
01153 {
01154 char base[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
01155 Buffer pass;
01156 int i, sz;
01157
01158 pass = make_Buffer(n);
01159 if (pass.buf==NULL) return pass;
01160
01161 sz = (int)strlen(base);
01162 for (i=0; i<n; i++) pass.buf[i] = base[rand()%sz];
01163 pass.vldsz = n;
01164
01165 return pass;
01166 }
01167
01168
01169
01178 Buffer randbit_Buffer(int n)
01179 {
01180 int i, sz;
01181 Buffer str;
01182
01183 sz = (n+7)/8;
01184 str = make_Buffer(sz);
01185 if (str.buf==NULL) return str;
01186 str.vldsz = sz;
01187
01188 for (i=0; i<n; i++) setBit(str.buf, i, rand()%2);
01189 return str;
01190 }
01191
01192
01193
01194 #define DUMP_BUFFER_LINE_SIZE 85 // 16*5("%02x "+"%c ") + 5(" "+"\r\n");
01195 #define DUMP_BUFFER_DELI_START 48 // 16*3("%02x ")
01196 #define DUMP_BUFFER_CHAR_START 51 // 16*3("%02x ") + 3(" ")
01197
01209 Buffer dump_Buffer(Buffer buf)
01210 {
01211 int sz;
01212 char wrkbuf[10];
01213 Buffer str = init_Buffer();
01214
01215 if (buf.buf==NULL) return str;
01216 if (buf.vldsz<0) sz = (int)strlen((const char*)buf.buf) + 1;
01217 else sz = buf.vldsz;
01218
01219 int lineno = (sz + 15)/16;
01220 str = make_Buffer(lineno*DUMP_BUFFER_LINE_SIZE+1);
01221
01222 int l;
01223 for (l=0; l<lineno; l++) {
01224 int sp = l*DUMP_BUFFER_LINE_SIZE;
01225 int i = 0;
01226 while (i<16) {
01227 sprintf(wrkbuf, "%02x ", buf.buf[l*16+i]);
01228 memcpy(str.buf+sp+i*3, wrkbuf, 3);
01229
01230 if (buf.buf[l*16+i]>=0x20 && buf.buf[l*16+i]<=0x7e) {
01231 sprintf(wrkbuf, "%c ", buf.buf[l*16+i]);
01232 memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, wrkbuf, 2);
01233 }
01234 else {
01235 memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, ". ", 2);
01236 }
01237
01238 if (l*16+i>=sz) {
01239 memcpy(str.buf+sp+i*3, " ", 3);
01240 memcpy(str.buf+sp+DUMP_BUFFER_CHAR_START+i*2, " ", 2);
01241 }
01242
01243 i++;
01244 }
01245 memcpy(str.buf+sp+DUMP_BUFFER_DELI_START, " ", 3);
01246 str.buf[sp+DUMP_BUFFER_LINE_SIZE-2] = '\r';
01247 str.buf[sp+DUMP_BUFFER_LINE_SIZE-1] = '\n';
01248 }
01249
01250 str.vldsz = lineno*DUMP_BUFFER_LINE_SIZE;
01251 return str;
01252 }
01253
01254
01255
01266 int recalc_strlen_Buffer(Buffer* buf)
01267 {
01268 int len = (int)strlen((char*)buf->buf);
01269 buf->vldsz = len;
01270 return len;
01271 }
01272
01273
01274
01283 void chomp_Buffer(Buffer* str)
01284 {
01285 int i, len;
01286
01287 if (str->buf==NULL) return;
01288
01289 len = (int)strlen((const char*)str->buf);
01290 for (i=0; i<len; i++) {
01291 if (str->buf[i]==CHAR_LF || str->buf[i]==CHAR_CR) {
01292 str->buf[i] = '\0';
01293 str->vldsz = (int)strlen((const char*)str->buf);
01294 return;
01295 }
01296 }
01297 }
01298
01299
01300
01310 int isText_Buffer(Buffer buf)
01311 {
01312 if (buf.vldsz==(int)strlen((const char*)buf.buf)) return TRUE;
01313 return FALSE;
01314 }
01315
01316
01317
01318
01320
01321
01322
01333 int fgets_Buffer(Buffer* str, FILE* fp)
01334 {
01335 char* p;
01336 int n, m;
01337 UNUSED(p);
01338
01339 memset(str->buf, 0, str->bufsz);
01340 p = fgets((char*)str->buf, str->bufsz, fp);
01341 m = (int)strlen((const char*)str->buf);
01342
01343 n = 0;
01344 while(str->buf[n]!=CHAR_LF && str->buf[n]!=CHAR_CR && str->buf[n]!='\0') n++;
01345 str->buf[n] = '\0';
01346 str->vldsz = n;
01347
01348
01349
01350 return m;
01351 }
01352
01353
01354
01365 int read_lines_Buffer(Buffer* str, FILE* fp)
01366 {
01367 Buffer buf;
01368 char* pp;
01369 UNUSED(pp);
01370
01371 buf = make_Buffer(str->bufsz);
01372 if (buf.buf==NULL) return JBXL_BUFFER_MAKE_ERROR;
01373
01374 pp = fgets((char*)buf.buf, buf.bufsz, fp);
01375 buf.vldsz = (int)strlen((const char*)buf.buf);
01376 copy_Buffer(&buf, str);
01377 clear_Buffer(&buf);
01378
01379 while (!feof(fp)) {
01380 pp = fgets((char*)buf.buf, buf.bufsz, fp);
01381 buf.vldsz = (int)strlen((const char*)buf.buf);
01382 cat_Buffer(&buf, str);
01383 clear_Buffer(&buf);
01384 }
01385
01386 free_Buffer(&buf);
01387 return str->vldsz;
01388 }
01389
01390
01391
01400 Buffer read_Buffer_file(const char* fn)
01401 {
01402 int sz;
01403 Buffer buf;
01404 FILE* fp;
01405
01406 buf = init_Buffer();
01407
01408 sz = file_size(fn);
01409 if (sz<=0) return buf;
01410
01411 fp = fopen(fn, "rb");
01412 if (fp==NULL) return buf;
01413
01414 buf = read_Buffer_data(fp, sz);
01415 fclose(fp);
01416
01417 return buf;
01418 }
01419
01420
01421
01431 Buffer read_Buffer_data(FILE* fp, int sz)
01432 {
01433 int cc;
01434 Buffer buf;
01435
01436 buf = init_Buffer();
01437 if (sz<0) return buf;
01438
01439 buf = make_Buffer(sz);
01440 if (buf.buf==NULL) return buf;
01441 buf.vldsz = sz;
01442
01443 cc = (int)fread(buf.buf, buf.vldsz, 1, fp);
01444 if (cc!=1) {
01445 free_Buffer(&buf);
01446 return buf;
01447 }
01448
01449 return buf;
01450 }
01451
01452
01453
01465 int save_Buffer_file(Buffer buf, char* fn)
01466 {
01467 int cc;
01468 FILE* fp;
01469
01470 fp = fopen(fn, "wb");
01471 if (fp==NULL) return FALSE;
01472
01473 cc = (int)fwrite(buf.buf, buf.vldsz, 1, fp);
01474 if (cc!=1) return FALSE;
01475 fclose(fp);
01476
01477 return TRUE;
01478 }
01479
01480
01481
01482
01484
01485
01486
01498 Buffer erase_bBuffer(Buffer buf, char* bin, int len)
01499 {
01500 int i, j, n;
01501 char cc;
01502
01503 Buffer res = dup_Buffer(buf);
01504 Buffer wrk = make_Buffer(buf.vldsz+1);
01505
01506 for (i=0; i<len; i++) {
01507 cc = bin[i];
01508 n = 0;
01509 for (j=0; j<res.vldsz; j++) {
01510 if (cc!=res.buf[j]) wrk.buf[n++] = res.buf[j];
01511 }
01512 wrk.vldsz = n;
01513
01514 copy_Buffer(&wrk, &res);
01515 clear_Buffer(&wrk);
01516 }
01517
01518 free_Buffer(&wrk);
01519
01520 return res;
01521 }
01522
01523
01524
01538 Buffer replace_sBuffer_bystr(Buffer buf, const char* frm, const char* tos)
01539 {
01540 int i, j, flen, tlen;
01541 Buffer res;
01542
01543 res = init_Buffer();
01544 if (buf.buf==NULL || frm==NULL || tos==NULL) return res;
01545
01546 flen = (int)strlen(frm);
01547 tlen = (int)strlen(tos);
01548 if (buf.vldsz<=0) buf.vldsz = (int)strlen((const char*)buf.buf);
01549
01550 int difsz = tlen - flen;
01551 if (difsz<0) difsz = 0;
01552 else difsz = difsz*100;
01553 res = make_Buffer((int)((buf.vldsz+difsz+1)*BUFFER_FACT));
01554
01555 i = j = 0;
01556 while (i<buf.vldsz && j<res.bufsz) {
01557 if (!strncmp((const char*)(buf.buf+i), frm, flen)){
01558 res.vldsz = (int)strlen((const char*)res.buf);
01559 cat_s2Buffer(tos, &res);
01560 i += flen;
01561 j += tlen;
01562 }
01563 else {
01564 res.buf[j++] = buf.buf[i++];
01565 }
01566 }
01567
01568 if (j==res.bufsz) res.state = JBXL_ERROR;
01569 res.vldsz = (int)strlen((const char*)res.buf);
01570
01571 return res;
01572 }
01573
01574
01575
01588 int replace_sBuffer_file(char* fn, Buffer frm, Buffer tos)
01589 {
01590 int ret;
01591 Buffer buf, res;
01592
01593 buf = read_Buffer_file(fn);
01594 if (buf.buf==NULL) return FALSE;
01595
01596 res = replace_sBuffer(buf, (char*)frm.buf, (char*)tos.buf);
01597 free_Buffer(&buf);
01598 if (res.buf==NULL) return FALSE;
01599
01600 ret = save_Buffer_file(res, fn);
01601 free_Buffer(&buf);
01602
01603 return ret;
01604 }
01605
01606
01607
01618 void rewrite_sBuffer_bystr(Buffer* buf, const char* frm, const char* tos)
01619 {
01620 Buffer tmp = replace_sBuffer_bystr(*buf, frm, tos);
01621 if (tmp.state==JBXL_NORMAL) {
01622 free_Buffer(buf);
01623 *buf = tmp;
01624 }
01625 return;
01626 }
01627
01628
01629
01630
01632
01633
01634
01648 int save_Buffer2_fp(Buffer key, Buffer buf, FILE* fp)
01649 {
01650 int cc;
01651
01652 cc = save_Buffer_fp(key, fp);
01653 if (!cc) return FALSE;
01654
01655 cc = save_Buffer_fp(buf, fp);
01656 if (!cc) return FALSE;
01657
01658 return TRUE;
01659 }
01660
01661
01662
01675 int save_Buffer_fp(Buffer buf, FILE* fp)
01676 {
01677 int cc, sz;
01678
01679 sz = htonl(buf.vldsz);
01680 cc = (int)fwrite(&sz, sizeof(sz), 1, fp);
01681 if (cc!=1) return FALSE;
01682
01683 cc = (int)fwrite(buf.buf, buf.vldsz, 1, fp);
01684 if (cc!=1) return FALSE;
01685
01686 return TRUE;
01687 }
01688
01689
01690
01700 Buffer read_Buffer_fp(FILE* fp)
01701 {
01702 int cc, sz;
01703 Buffer buf;
01704
01705 buf = init_Buffer();
01706 cc = (int)fread(&sz, sizeof(sz), 1, fp);
01707 if (cc!=1) return buf;
01708 sz = ntohl(sz);
01709
01710 buf = make_Buffer(sz);
01711 if (buf.buf==NULL) return buf;
01712 buf.vldsz = sz;
01713 cc = (int)fread(buf.buf, buf.vldsz, 1, fp);
01714 if (cc!=1) {
01715 free_Buffer(&buf);
01716 return buf;
01717 }
01718
01719 return buf;
01720 }
01721
01722
01723
01737 int read_Buffer2_fp(Buffer* key, Buffer* buf, FILE* fp)
01738 {
01739 if (key==NULL || buf==NULL) return FALSE;
01740
01741 *key = init_Buffer();
01742 *buf = init_Buffer();
01743
01744 *key = read_Buffer_fp(fp);
01745 if (key->buf==NULL) return FALSE;
01746
01747 *buf = read_Buffer_fp(fp);
01748 if (buf->buf==NULL) {
01749 free_Buffer(key);
01750 return FALSE;
01751 }
01752
01753 return TRUE;
01754 }
01755
01756
01757
01758
01760
01761
01762
01763
01764
01765
01766
01767
01768
01774 char pop_char_ringStack(Buffer* buf)
01775 {
01776 buf->vldsz--;
01777 if (buf->vldsz<0) buf->vldsz = buf->bufsz - 1;
01778
01779 return (char)buf->buf[buf->vldsz];
01780 }
01781
01782
01783
01789 void push_char_ringStack(Buffer* buf, char cc)
01790 {
01791 buf->buf[buf->vldsz] = (unsigned char)cc;
01792 buf->vldsz++;
01793 if (buf->vldsz==buf->bufsz) buf->vldsz = 0;
01794
01795 return;
01796 }
01797
01798
