https://github.com/huangz1990/redis-3.0-annotated/blob/unstable/src/sds.c#L120
1 /* SDSLib, A C dynamic strings library 2 * 3 * Copyright (c) 2006-2012, Salvatore Sanfilippo <antirez at gmail dot com> 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions are met: 8 * 9 * * Redistributions of source code must retain the above copyright notice, 10 * this list of conditions and the following disclaimer. 11 * * Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * * Neither the name of Redis nor the names of its contributors may be used 15 * to endorse or promote products derived from this software without 16 * specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 19 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 20 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 21 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 22 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 23 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 24 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 25 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 26 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 27 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 28 * POSSIBILITY OF SUCH DAMAGE. 29 */ 30 31 #include <stdio.h> 32 #include <stdlib.h> 33 #include <string.h> 34 #include <ctype.h> 35 #include <assert.h> 36 #include "sds.h" 37 #include "zmalloc.h" 38 39 /* 40 * 根据给定的初始化字符串 init 和字符串长度 initlen 41 * 创建一个新的 sds 42 * 43 * 参数 44 * init ：初始化字符串指针 45 * initlen ：初始化字符串的长度 46 * 47 * 返回值 48 * sds ：创建成功返回 sdshdr 相对应的 sds 49 * 创建失败返回 NULL 50 * 51 * 复杂度 52 * T = O(N) 53 */ 54 /* Create a new sds string with the content specified by the 'init' pointer 55 * and 'initlen'. 56 * If NULL is used for 'init' the string is initialized with zero bytes. 57 * 58 * The string is always null-termined (all the sds strings are, always) so 59 * even if you create an sds string with: 60 * 61 * mystring = sdsnewlen("abc",3"); 62 * 63 * You can print the string with printf() as there is an implicit \0 at the 64 * end of the string. However the string is binary safe and can contain 65 * \0 characters in the middle, as the length is stored in the sds header. */ 66 sds sdsnewlen(const void *init, size_t initlen) { 67 68 struct sdshdr *sh; 69 70 // 根据是否有初始化内容，选择适当的内存分配方式 71 // T = O(N) 72 if (init) { 73 // zmalloc 不初始化所分配的内存 74 sh = zmalloc(sizeof(struct sdshdr)+initlen+1); 75 } else { 76 // zcalloc 将分配的内存全部初始化为 0 77 sh = zcalloc(sizeof(struct sdshdr)+initlen+1); 78 } 79 80 // 内存分配失败，返回 81 if (sh == NULL) return NULL; 82 83 // 设置初始化长度 84 sh->len = initlen; 85 // 新 sds 不预留任何空间 86 sh->free = 0; 87 // 如果有指定初始化内容，将它们复制到 sdshdr 的 buf 中 88 // T = O(N) 89 if (initlen && init) 90 memcpy(sh->buf, init, initlen); 91 // 以 \0 结尾 92 sh->buf[initlen] = '\0'; 93 94 // 返回 buf 部分，而不是整个 sdshdr 95 return (char*)sh->buf; 96 } 97 98 /* 99 * 创建并返回一个只保存了空字符串 "" 的 sds 100 * 101 * 返回值 102 * sds ：创建成功返回 sdshdr 相对应的 sds 103 * 创建失败返回 NULL 104 * 105 * 复杂度 106 * T = O(1) 107 */ 108 /* Create an empty (zero length) sds string. Even in this case the string 109 * always has an implicit null term. */ 110 sds sdsempty(void) { 111 return sdsnewlen("",0); 112 } 113 114 /* 115 * 根据给定字符串 init ，创建一个包含同样字符串的 sds 116 * 117 * 参数 118 * init ：如果输入为 NULL ，那么创建一个空白 sds 119 * 否则，新创建的 sds 中包含和 init 内容相同字符串 120 * 121 * 返回值 122 * sds ：创建成功返回 sdshdr 相对应的 sds 123 * 创建失败返回 NULL 124 * 125 * 复杂度 126 * T = O(N) 127 */ 128 /* Create a new sds string starting from a null termined C string. */ 129 sds sdsnew(const char *init) { 130 size_t initlen = (init == NULL) ? 0 : strlen(init); 131 return sdsnewlen(init, initlen); 132 } 133 134 /* 135 * 复制给定 sds 的副本 136 * 137 * 返回值 138 * sds ：创建成功返回输入 sds 的副本 139 * 创建失败返回 NULL 140 * 141 * 复杂度 142 * T = O(N) 143 */ 144 /* Duplicate an sds string. */ 145 sds sdsdup(const sds s) { 146 return sdsnewlen(s, sdslen(s)); 147 } 148 149 /* 150 * 释放给定的 sds 151 * 152 * 复杂度 153 * T = O(N) 154 */ 155 /* Free an sds string. No operation is performed if 's' is NULL. */ 156 void sdsfree(sds s) { 157 if (s == NULL) return; 158 zfree(s-sizeof(struct sdshdr)); 159 } 160 161 // 未使用函数，可能已废弃 162 /* Set the sds string length to the length as obtained with strlen(), so 163 * considering as content only up to the first null term character. 164 * 165 * This function is useful when the sds string is hacked manually in some 166 * way, like in the following example: 167 * 168 * s = sdsnew("foobar"); 169 * s[2] = '\0'; 170 * sdsupdatelen(s); 171 * printf("%d\n", sdslen(s)); 172 * 173 * The output will be "2", but if we comment out the call to sdsupdatelen() 174 * the output will be "6" as the string was modified but the logical length 175 * remains 6 bytes. */ 176 void sdsupdatelen(sds s) { 177 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 178 int reallen = strlen(s); 179 sh->free += (sh->len-reallen); 180 sh->len = reallen; 181 } 182 183 /* 184 * 在不释放 SDS 的字符串空间的情况下，（通过惰性空间释放策略， SDS 避免了缩短字符串时所需的内存重分配操作， 并为将来可能有的增长操作提供了优化。） 185 * 重置 SDS 所保存的字符串为空字符串。 186 * 187 * 复杂度 188 * T = O(1) 189 */ 190 /* Modify an sds string on-place to make it empty (zero length). 191 * However all the existing buffer is not discarded but set as free space 192 * so that next append operations will not require allocations up to the 193 * number of bytes previously available. */ 194 void sdsclear(sds s) { 195 196 // 取出 sdshdr 197 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 198 199 // 重新计算属性 200 sh->free += sh->len; 201 sh->len = 0; 202 203 // 将结束符放到最前面（相当于惰性地删除 buf 中的内容） 204 sh->buf[0] = '\0'; 205 } 206 207 /* Enlarge the free space at the end of the sds string so that the caller 208 * is sure that after calling this function can overwrite up to addlen 209 * bytes after the end of the string, plus one more byte for nul term. 210 * 211 * Note: this does not change the *length* of the sds string as returned 212 * by sdslen(), but only the free buffer space we have. */ 213 /* 214 * 对 sds 中 buf 的长度进行扩展，确保在函数执行之后， 215 * buf 至少会有 addlen + 1 长度的空余空间 216 * （额外的 1 字节是为 \0 准备的） 217 * 218 * 返回值 219 * sds ：扩展成功返回扩展后的 sds 220 * 扩展失败返回 NULL 221 * 222 * 复杂度 223 * T = O(N) 224 */ 225 sds sdsMakeRoomFor(sds s, size_t addlen) { 226 227 struct sdshdr *sh, *newsh; 228 229 // 获取 s 目前的空余空间长度 230 size_t free = sdsavail(s); 231 232 size_t len, newlen; 233 234 // s 目前的空余空间已经足够，无须再进行扩展，直接返回 235 if (free >= addlen) return s; 236 237 // 获取 s 目前已占用空间的长度 238 len = sdslen(s); 239 sh = (void*) (s-(sizeof(struct sdshdr))); 240 241 // s 最少需要的长度 242 newlen = (len+addlen); 243 244 // 根据新长度，为 s 分配新空间所需的大小 245 if (newlen < SDS_MAX_PREALLOC) 246 // 如果新长度小于 SDS_MAX_PREALLOC 247 // 那么为它分配两倍于所需长度的空间 248 newlen *= 2; 249 else 250 // 否则，分配长度为目前长度加上 SDS_MAX_PREALLOC 251 newlen += SDS_MAX_PREALLOC; 252 // T = O(N) 253 newsh = zrealloc(sh, sizeof(struct sdshdr)+newlen+1); 254 255 // 内存不足，分配失败，返回 256 if (newsh == NULL) return NULL; 257 258 // 更新 sds 的空余长度 259 newsh->free = newlen - len; 260 261 // 返回 sds 262 return newsh->buf; 263 } 264 265 /* 266 * 回收 sds 中的空闲空间， 267 * 回收不会对 sds 中保存的字符串内容做任何修改。 268 * 269 * 返回值 270 * sds ：内存调整后的 sds 271 * 272 * 复杂度 273 * T = O(N) 274 */ 275 /* Reallocate the sds string so that it has no free space at the end. The 276 * contained string remains not altered, but next concatenation operations 277 * will require a reallocation. 278 * 279 * After the call, the passed sds string is no longer valid and all the 280 * references must be substituted with the new pointer returned by the call. */ 281 sds sdsRemoveFreeSpace(sds s) { 282 struct sdshdr *sh; 283 284 sh = (void*) (s-(sizeof(struct sdshdr))); 285 286 // 进行内存重分配，让 buf 的长度仅仅足够保存字符串内容 287 // T = O(N) 288 sh = zrealloc(sh, sizeof(struct sdshdr)+sh->len+1); 289 290 // 空余空间为 0 291 sh->free = 0; 292 293 return sh->buf; 294 } 295 296 /* 297 * 返回给定 sds 分配的内存字节数 298 * 299 * 复杂度 300 * T = O(1) 301 */ 302 /* Return the total size of the allocation of the specifed sds string, 303 * including: 304 * 1) The sds header before the pointer. 305 * 2) The string. 306 * 3) The free buffer at the end if any. 307 * 4) The implicit null term. 308 */ 309 size_t sdsAllocSize(sds s) { 310 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 311 312 return sizeof(*sh)+sh->len+sh->free+1; 313 } 314 315 /* Increment the sds length and decrements the left free space at the 316 * end of the string according to 'incr'. Also set the null term 317 * in the new end of the string. 318 * 319 * 根据 incr 参数，增加 sds 的长度，缩减空余空间， 320 * 并将 \0 放到新字符串的尾端 321 * 322 * This function is used in order to fix the string length after the 323 * user calls sdsMakeRoomFor(), writes something after the end of 324 * the current string, and finally needs to set the new length. 325 * 326 * 这个函数是在调用 sdsMakeRoomFor() 对字符串进行扩展， 327 * 然后用户在字符串尾部写入了某些内容之后， 328 * 用来正确更新 free 和 len 属性的。 329 * 330 * Note: it is possible to use a negative increment in order to 331 * right-trim the string. 332 * 333 * 如果 incr 参数为负数，那么对字符串进行右截断操作。 334 * 335 * Usage example: 336 * 337 * Using sdsIncrLen() and sdsMakeRoomFor() it is possible to mount the 338 * following schema, to cat bytes coming from the kernel to the end of an 339 * sds string without copying into an intermediate buffer: 340 * 341 * 以下是 sdsIncrLen 的用例： 342 * 343 * oldlen = sdslen(s); 344 * s = sdsMakeRoomFor(s, BUFFER_SIZE); 345 * nread = read(fd, s+oldlen, BUFFER_SIZE); 346 * ... check for nread <= 0 and handle it ... 347 * sdsIncrLen(s, nread); 348 * 349 * 复杂度 350 * T = O(1) 351 */ 352 void sdsIncrLen(sds s, int incr) { 353 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 354 355 // 确保 sds 空间足够 356 assert(sh->free >= incr); 357 358 // 更新属性 359 sh->len += incr; 360 sh->free -= incr; 361 362 // 这个 assert 其实可以忽略 363 // 因为前一个 assert 已经确保 sh->free - incr >= 0 了 364 assert(sh->free >= 0); 365 366 // 放置新的结尾符号 367 s[sh->len] = '\0'; 368 } 369 370 /* Grow the sds to have the specified length. Bytes that were not part of 371 * the original length of the sds will be set to zero. 372 * 373 * if the specified length is smaller than the current length, no operation 374 * is performed. */ 375 /* 376 * 将 sds 扩充至指定长度，未使用的空间以 0 字节填充。 377 * 378 * 返回值 379 * sds ：扩充成功返回新 sds ，失败返回 NULL 380 * 381 * 复杂度： 382 * T = O(N) 383 */ 384 sds sdsgrowzero(sds s, size_t len) { 385 struct sdshdr *sh = (void*)(s-(sizeof(struct sdshdr))); 386 size_t totlen, curlen = sh->len; 387 388 // 如果 len 比字符串的现有长度小， 389 // 那么直接返回，不做动作 390 if (len <= curlen) return s; 391 392 // 扩展 sds 393 // T = O(N) 394 s = sdsMakeRoomFor(s,len-curlen); 395 // 如果内存不足，直接返回 396 if (s == NULL) return NULL; 397 398 /* Make sure added region doesn't contain garbage */ 399 // 将新分配的空间用 0 填充，防止出现垃圾内容 400 // T = O(N) 401 sh = (void*)(s-(sizeof(struct sdshdr))); 402 memset(s+curlen,0,(len-curlen+1)); /* also set trailing \0 byte */ 403 404 // 更新属性 405 totlen = sh->len+sh->free; 406 sh->len = len; 407 sh->free = totlen-sh->len; 408 409 // 返回新的 sds 410 return s; 411 } 412 413 /* 414 * 将长度为 len 的字符串 t 追加到 sds 的字符串末尾 415 * 416 * 返回值 417 * sds ：追加成功返回新 sds ，失败返回 NULL 418 * 419 * 复杂度 420 * T = O(N) 421 */ 422 /* Append the specified binary-safe string pointed by 't' of 'len' bytes to the 423 * end of the specified sds string 's'. 424 * 425 * After the call, the passed sds string is no longer valid and all the 426 * references must be substituted with the new pointer returned by the call. */ 427 sds sdscatlen(sds s, const void *t, size_t len) { 428 429 struct sdshdr *sh; 430 431 // 原有字符串长度 432 size_t curlen = sdslen(s); 433 434 // 扩展 sds 空间 435 // T = O(N) 436 s = sdsMakeRoomFor(s,len); 437 438 // 内存不足？直接返回 439 if (s == NULL) return NULL; 440 441 // 复制 t 中的内容到字符串后部 442 // T = O(N) 443 sh = (void*) (s-(sizeof(struct sdshdr))); 444 memcpy(s+curlen, t, len); 445 446 // 更新属性 447 sh->len = curlen+len; 448 sh->free = sh->free-len; 449 450 // 添加新结尾符号 451 s[curlen+len] = '\0'; 452 453 // 返回新 sds 454 return s; 455 } 456 457 /* 458 * 将给定字符串 t 追加到 sds 的末尾 459 * 460 * 返回值 461 * sds ：追加成功返回新 sds ，失败返回 NULL 462 * 463 * 复杂度 464 * T = O(N) 465 */ 466 /* Append the specified null termianted C string to the sds string 's'. 467 * 468 * After the call, the passed sds string is no longer valid and all the 469 * references must be substituted with the new pointer returned by the call. */ 470 sds sdscat(sds s, const char *t) { 471 return sdscatlen(s, t, strlen(t)); 472 } 473 474 /* 475 * 将另一个 sds 追加到一个 sds 的末尾 476 * 477 * 返回值 478 * sds ：追加成功返回新 sds ，失败返回 NULL 479 * 480 * 复杂度 481 * T = O(N) 482 */ 483 /* Append the specified sds 't' to the existing sds 's'. 484 * 485 * After the call, the modified sds string is no longer valid and all the 486 * references must be substituted with the new pointer returned by the call. */ 487 sds sdscatsds(sds s, const sds t) { 488 return sdscatlen(s, t, sdslen(t)); 489 } 490 491 /* 492 * 将字符串 t 的前 len 个字符复制到 sds s 当中， 493 * 并在字符串的最后添加终结符。 494 * 495 * 如果 sds 的长度少于 len 个字符，那么扩展 sds 496 * 497 * 复杂度 498 * T = O(N) 499 * 500 * 返回值 501 * sds ：复制成功返回新的 sds ，否则返回 NULL 502 */ 503 /* Destructively modify the sds string 's' to hold the specified binary 504 * safe string pointed by 't' of length 'len' bytes. */ 505 sds sdscpylen(sds s, const char *t, size_t len) { 506 507 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 508 509 // sds 现有 buf 的长度 510 size_t totlen = sh->free+sh->len; 511 512 // 如果 s 的 buf 长度不满足 len ，那么扩展它 513 if (totlen < len) { 514 // T = O(N) 515 s = sdsMakeRoomFor(s,len-sh->len); 516 if (s == NULL) return NULL; 517 sh = (void*) (s-(sizeof(struct sdshdr))); 518 totlen = sh->free+sh->len; 519 } 520 521 // 复制内容 522 // T = O(N) 523 memcpy(s, t, len); 524 525 // 添加终结符号 526 s[len] = '\0'; 527 528 // 更新属性 529 sh->len = len; 530 sh->free = totlen-len; 531 532 // 返回新的 sds 533 return s; 534 } 535 536 /* 537 * 将字符串复制到 sds 当中， 538 * 覆盖原有的字符。 539 * 540 * 如果 sds 的长度少于字符串的长度，那么扩展 sds 。 541 * 542 * 复杂度 543 * T = O(N) 544 * 545 * 返回值 546 * sds ：复制成功返回新的 sds ，否则返回 NULL 547 */ 548 /* Like sdscpylen() but 't' must be a null-termined string so that the length 549 * of the string is obtained with strlen(). */ 550 sds sdscpy(sds s, const char *t) { 551 return sdscpylen(s, t, strlen(t)); 552 } 553 554 /* Helper for sdscatlonglong() doing the actual number -> string 555 * conversion. 's' must point to a string with room for at least 556 * SDS_LLSTR_SIZE bytes. 557 * 558 * The function returns the lenght of the null-terminated string 559 * representation stored at 's'. */ 560 #define SDS_LLSTR_SIZE 21 561 int sdsll2str(char *s, long long value) { 562 char *p, aux; 563 unsigned long long v; 564 size_t l; 565 566 /* Generate the string representation, this method produces 567 * an reversed string. */ 568 v = (value < 0) ? -value : value; 569 p = s; 570 do { 571 *p++ = '0'+(v%10); 572 v /= 10; 573 } while(v); 574 if (value < 0) *p++ = '-'; 575 576 /* Compute length and add null term. */ 577 l = p-s; 578 *p = '\0'; 579 580 /* Reverse the string. */ 581 p--; 582 while(s < p) { 583 aux = *s; 584 *s = *p; 585 *p = aux; 586 s++; 587 p--; 588 } 589 return l; 590 } 591 592 /* Identical sdsll2str(), but for unsigned long long type. */ 593 int sdsull2str(char *s, unsigned long long v) { 594 char *p, aux; 595 size_t l; 596 597 /* Generate the string representation, this method produces 598 * an reversed string. */ 599 p = s; 600 do { 601 *p++ = '0'+(v%10); 602 v /= 10; 603 } while(v); 604 605 /* Compute length and add null term. */ 606 l = p-s; 607 *p = '\0'; 608 609 /* Reverse the string. */ 610 p--; 611 while(s < p) { 612 aux = *s; 613 *s = *p; 614 *p = aux; 615 s++; 616 p--; 617 } 618 return l; 619 } 620 621 /* Create an sds string from a long long value. It is much faster than: 622 * 623 * sdscatprintf(sdsempty(),"%lld\n", value); 624 */ 625 // 根据输入的 long long 值 value ，创建一个 SDS 626 sds sdsfromlonglong(long long value) { 627 char buf[SDS_LLSTR_SIZE]; 628 int len = sdsll2str(buf,value); 629 630 return sdsnewlen(buf,len); 631 } 632 633 /* 634 * 打印函数，被 sdscatprintf 所调用 635 * 636 * T = O(N^2) 637 */ 638 /* Like sdscatpritf() but gets va_list instead of being variadic. */ 639 sds sdscatvprintf(sds s, const char *fmt, va_list ap) { 640 va_list cpy; 641 char staticbuf[1024], *buf = staticbuf, *t; 642 size_t buflen = strlen(fmt)*2; 643 644 /* We try to start using a static buffer for speed. 645 * If not possible we revert to heap allocation. */ 646 if (buflen > sizeof(staticbuf)) { 647 buf = zmalloc(buflen); 648 if (buf == NULL) return NULL; 649 } else { 650 buflen = sizeof(staticbuf); 651 } 652 653 /* Try with buffers two times bigger every time we fail to 654 * fit the string in the current buffer size. */ 655 while(1) { 656 buf[buflen-2] = '\0'; 657 va_copy(cpy,ap); 658 // T = O(N) 659 vsnprintf(buf, buflen, fmt, cpy); 660 if (buf[buflen-2] != '\0') { 661 if (buf != staticbuf) zfree(buf); 662 buflen *= 2; 663 buf = zmalloc(buflen); 664 if (buf == NULL) return NULL; 665 continue; 666 } 667 break; 668 } 669 670 /* Finally concat the obtained string to the SDS string and return it. */ 671 t = sdscat(s, buf); 672 if (buf != staticbuf) zfree(buf); 673 return t; 674 } 675 676 /* 677 * 打印任意数量个字符串，并将这些字符串追加到给定 sds 的末尾 678 * 679 * T = O(N^2) 680 */ 681 /* Append to the sds string 's' a string obtained using printf-alike format 682 * specifier. 683 * 684 * After the call, the modified sds string is no longer valid and all the 685 * references must be substituted with the new pointer returned by the call. 686 * 687 * Example: 688 * 689 * s = sdsempty("Sum is: "); 690 * s = sdscatprintf(s,"%d+%d = %d",a,b,a+b). 691 * 692 * Often you need to create a string from scratch with the printf-alike 693 * format. When this is the need, just use sdsempty() as the target string: 694 * 695 * s = sdscatprintf(sdsempty(), "... your format ...", args); 696 */ 697 sds sdscatprintf(sds s, const char *fmt, ...) { 698 va_list ap; 699 char *t; 700 va_start(ap, fmt); 701 // T = O(N^2) 702 t = sdscatvprintf(s,fmt,ap); 703 va_end(ap); 704 return t; 705 } 706 707 /* This function is similar to sdscatprintf, but much faster as it does 708 * not rely on sprintf() family functions implemented by the libc that 709 * are often very slow. Moreover directly handling the sds string as 710 * new data is concatenated provides a performance improvement. 711 * 712 * However this function only handles an incompatible subset of printf-alike 713 * format specifiers: 714 * 715 * %s - C String 716 * %S - SDS string 717 * %i - signed int 718 * %I - 64 bit signed integer (long long, int64_t) 719 * %u - unsigned int 720 * %U - 64 bit unsigned integer (unsigned long long, uint64_t) 721 * %% - Verbatim "%" character. 722 */ 723 sds sdscatfmt(sds s, char const *fmt, ...) { 724 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 725 size_t initlen = sdslen(s); 726 const char *f = fmt; 727 int i; 728 va_list ap; 729 730 va_start(ap,fmt); 731 f = fmt; /* Next format specifier byte to process. */ 732 i = initlen; /* Position of the next byte to write to dest str. */ 733 while(*f) { 734 char next, *str; 735 size_t l; 736 long long num; 737 unsigned long long unum; 738 739 /* Make sure there is always space for at least 1 char. */ 740 if (sh->free == 0) { 741 s = sdsMakeRoomFor(s,1); 742 sh = (void*) (s-(sizeof(struct sdshdr))); 743 } 744 745 switch(*f) { 746 case '%': 747 next = *(f+1); 748 f++; 749 switch(next) { 750 case 's': 751 case 'S': 752 str = va_arg(ap,char*); 753 l = (next == 's') ? strlen(str) : sdslen(str); 754 if (sh->free < l) { 755 s = sdsMakeRoomFor(s,l); 756 sh = (void*) (s-(sizeof(struct sdshdr))); 757 } 758 memcpy(s+i,str,l); 759 sh->len += l; 760 sh->free -= l; 761 i += l; 762 break; 763 case 'i': 764 case 'I': 765 if (next == 'i') 766 num = va_arg(ap,int); 767 else 768 num = va_arg(ap,long long); 769 { 770 char buf[SDS_LLSTR_SIZE]; 771 l = sdsll2str(buf,num); 772 if (sh->free < l) { 773 s = sdsMakeRoomFor(s,l); 774 sh = (void*) (s-(sizeof(struct sdshdr))); 775 } 776 memcpy(s+i,buf,l); 777 sh->len += l; 778 sh->free -= l; 779 i += l; 780 } 781 break; 782 case 'u': 783 case 'U': 784 if (next == 'u') 785 unum = va_arg(ap,unsigned int); 786 else 787 unum = va_arg(ap,unsigned long long); 788 { 789 char buf[SDS_LLSTR_SIZE]; 790 l = sdsull2str(buf,unum); 791 if (sh->free < l) { 792 s = sdsMakeRoomFor(s,l); 793 sh = (void*) (s-(sizeof(struct sdshdr))); 794 } 795 memcpy(s+i,buf,l); 796 sh->len += l; 797 sh->free -= l; 798 i += l; 799 } 800 break; 801 default: /* Handle %% and generally %<unknown>. */ 802 s[i++] = next; 803 sh->len += 1; 804 sh->free -= 1; 805 break; 806 } 807 break; 808 default: 809 s[i++] = *f; 810 sh->len += 1; 811 sh->free -= 1; 812 break; 813 } 814 f++; 815 } 816 va_end(ap); 817 818 /* Add null-term */ 819 s[i] = '\0'; 820 return s; 821 } 822 823 /* 824 * 对 sds 左右两端进行修剪，清除其中 cset 指定的所有字符 825 * 826 * 比如 sdsstrim(xxyyabcyyxy, "xy") 将返回 "abc" 827 * 828 * 复杂性： 829 * T = O(M*N)，M 为 SDS 长度， N 为 cset 长度。 830 */ 831 /* Remove the part of the string from left and from right composed just of 832 * contiguous characters found in 'cset', that is a null terminted C string. 833 * 834 * After the call, the modified sds string is no longer valid and all the 835 * references must be substituted with the new pointer returned by the call. 836 * 837 * Example: 838 * 839 * s = sdsnew("AA...AA.a.aa.aHelloWorld :::"); 840 * s = sdstrim(s,"A. :"); 841 * printf("%s\n", s); 842 * 843 * Output will be just "Hello World". 844 */ 845 sds sdstrim(sds s, const char *cset) { 846 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 847 char *start, *end, *sp, *ep; 848 size_t len; 849 850 // 设置和记录指针 851 sp = start = s; 852 ep = end = s+sdslen(s)-1; 853 854 // 修剪, T = O(N^2) 855 while(sp <= end && strchr(cset, *sp)) sp++; 856 while(ep > start && strchr(cset, *ep)) ep--; 857 858 // 计算 trim 完毕之后剩余的字符串长度 859 len = (sp > ep) ? 0 : ((ep-sp)+1); 860 861 // 如果有需要，前移字符串内容 862 // T = O(N) 863 if (sh->buf != sp) memmove(sh->buf, sp, len); 864 865 // 添加终结符 866 sh->buf[len] = '\0'; 867 868 // 更新属性 869 sh->free = sh->free+(sh->len-len); 870 sh->len = len; 871 872 // 返回修剪后的 sds 873 return s; 874 } 875 876 /* 877 * 按索引对截取 sds 字符串的其中一段 878 * start 和 end 都是闭区间（包含在内） 879 * 880 * 索引从 0 开始，最大为 sdslen(s) - 1 881 * 索引可以是负数， sdslen(s) - 1 == -1 882 * 883 * 复杂度 884 * T = O(N) 885 */ 886 /* Turn the string into a smaller (or equal) string containing only the 887 * substring specified by the 'start' and 'end' indexes. 888 * 889 * start and end can be negative, where -1 means the last character of the 890 * string, -2 the penultimate character, and so forth. 891 * 892 * The interval is inclusive, so the start and end characters will be part 893 * of the resulting string. 894 * 895 * The string is modified in-place. 896 * 897 * Example: 898 * 899 * s = sdsnew("Hello World"); 900 * sdsrange(s,1,-1); => "ello World" 901 */ 902 void sdsrange(sds s, int start, int end) { 903 struct sdshdr *sh = (void*) (s-(sizeof(struct sdshdr))); 904 size_t newlen, len = sdslen(s); 905 906 if (len == 0) return; 907 if (start < 0) { 908 start = len+start; 909 if (start < 0) start = 0; 910 } 911 if (end < 0) { 912 end = len+end; 913 if (end < 0) end = 0; 914 } 915 newlen = (start > end) ? 0 : (end-start)+1; 916 if (newlen != 0) { 917 if (start >= (signed)len) { 918 newlen = 0; 919 } else if (end >= (signed)len) { 920 end = len-1; 921 newlen = (start > end) ? 0 : (end-start)+1; 922 } 923 } else { 924 start = 0; 925 } 926 927 // 如果有需要，对字符串进行移动 928 // T = O(N) 929 if (start && newlen) memmove(sh->buf, sh->buf+start, newlen); 930 931 // 添加终结符 932 sh->buf[newlen] = 0; 933 934 // 更新属性 935 sh->free = sh->free+(sh->len-newlen); 936 sh->len = newlen; 937 } 938 939 /* 940 * 将 sds 字符串中的所有字符转换为小写 941 * 942 * T = O(N) 943 */ 944 /* Apply tolower() to every character of the sds string 's'. */ 945 void sdstolower(sds s) { 946 int len = sdslen(s), j; 947 948 for (j = 0; j < len; j++) s[j] = tolower(s[j]); 949 } 950 951 /* 952 * 将 sds 字符串中的所有字符转换为大写 953 * 954 * T = O(N) 955 */ 956 /* Apply toupper() to every character of the sds string 's'. */ 957 void sdstoupper(sds s) { 958 int len = sdslen(s), j; 959 960 for (j = 0; j < len; j++) s[j] = toupper(s[j]); 961 } 962 963 /* 964 * 对比两个 sds ， strcmp 的 sds 版本 965 * 966 * 返回值 967 * int ：相等返回 0 ，s1 较大返回正数， s2 较大返回负数 968 * 969 * T = O(N) 970 */ 971 /* Compare two sds strings s1 and s2 with memcmp(). 972 * 973 * Return value: 974 * 975 * 1 if s1 > s2. 976 * -1 if s1 < s2. 977 * 0 if s1 and s2 are exactly the same binary string. 978 * 979 * If two strings share exactly the same prefix, but one of the two has 980 * additional characters, the longer string is considered to be greater than 981 * the smaller one. */ 982 int sdscmp(const sds s1, const sds s2) { 983 size_t l1, l2, minlen; 984 int cmp; 985 986 l1 = sdslen(s1); 987 l2 = sdslen(s2); 988 minlen = (l1 < l2) ? l1 : l2; 989 cmp = memcmp(s1,s2,minlen); 990 991 if (cmp == 0) return l1-l2; 992 993 return cmp; 994 } 995 996 /* Split 's' with separator in 'sep'. An array 997 * of sds strings is returned. *count will be set 998 * by reference to the number of tokens returned. 999 * 1000 * 使用分隔符 sep 对 s 进行分割，返回一个 sds 字符串的数组。 1001 * *count 会被设置为返回数组元素的数量。 1002 * 1003 * On out of memory, zero length string, zero length 1004 * separator, NULL is returned. 1005 * 1006 * 如果出现内存不足、字符串长度为 0 或分隔符长度为 0 1007 * 的情况，返回 NULL 1008 * 1009 * Note that 'sep' is able to split a string using 1010 * a multi-character separator. For example 1011 * sdssplit("foo_-_bar","_-_"); will return two 1012 * elements "foo" and "bar". 1013 * 1014 * 注意分隔符可以的是包含多个字符的字符串 1015 * 1016 * This version of the function is binary-safe but 1017 * requires length arguments. sdssplit() is just the 1018 * same function but for zero-terminated strings. 1019 * 1020 * 这个函数接受 len 参数，因此它是二进制安全的。 1021 * （文档中提到的 sdssplit() 已废弃） 1022 * 1023 * T = O(N^2) 1024 */ 1025 sds *sdssplitlen(const char *s, int len, const char *sep, int seplen, int *count) { 1026 int elements = 0, slots = 5, start = 0, j; 1027 sds *tokens; 1028 1029 if (seplen < 1 || len < 0) return NULL; 1030 1031 tokens = zmalloc(sizeof(sds)*slots); 1032 if (tokens == NULL) return NULL; 1033 1034 if (len == 0) { 1035 *count = 0; 1036 return tokens; 1037 } 1038 1039 // T = O(N^2) 1040 for (j = 0; j < (len-(seplen-1)); j++) { 1041 /* make sure there is room for the next element and the final one */ 1042 if (slots < elements+2) { 1043 sds *newtokens; 1044 1045 slots *= 2; 1046 newtokens = zrealloc(tokens,sizeof(sds)*slots); 1047 if (newtokens == NULL) goto cleanup; 1048 tokens = newtokens; 1049 } 1050 /* search the separator */ 1051 // T = O(N) 1052 if ((seplen == 1 && *(s+j) == sep[0]) || (memcmp(s+j,sep,seplen) == 0)) { 1053 tokens[elements] = sdsnewlen(s+start,j-start); 1054 if (tokens[elements] == NULL) goto cleanup; 1055 elements++; 1056 start = j+seplen; 1057 j = j+seplen-1; /* skip the separator */ 1058 } 1059 } 1060 /* Add the final element. We are sure there is room in the tokens array. */ 1061 tokens[elements] = sdsnewlen(s+start,len-start); 1062 if (tokens[elements] == NULL) goto cleanup; 1063 elements++; 1064 *count = elements; 1065 return tokens; 1066 1067 cleanup: 1068 { 1069 int i; 1070 for (i = 0; i < elements; i++) sdsfree(tokens[i]); 1071 zfree(tokens); 1072 *count = 0; 1073 return NULL; 1074 } 1075 } 1076 1077 /* 1078 * 释放 tokens 数组中 count 个 sds 1079 * 1080 * T = O(N^2) 1081 */ 1082 /* Free the result returned by sdssplitlen(), or do nothing if 'tokens' is NULL. */ 1083 void sdsfreesplitres(sds *tokens, int count) { 1084 if (!tokens) return; 1085 while(count--) 1086 sdsfree(tokens[count]); 1087 zfree(tokens); 1088 } 1089 1090 /* 1091 * 将长度为 len 的字符串 p 以带引号（quoted）的格式 1092 * 追加到给定 sds 的末尾 1093 * 1094 * T = O(N) 1095 */ 1096 /* Append to the sds string "s" an escaped string representation where 1097 * all the non-printable characters (tested with isprint()) are turned into 1098 * escapes in the form "\n\r\a...." or "\x<hex-number>". 1099 * 1100 * After the call, the modified sds string is no longer valid and all the 1101 * references must be substituted with the new pointer returned by the call. */ 1102 sds sdscatrepr(sds s, const char *p, size_t len) { 1103 1104 s = sdscatlen(s,"\"",1); 1105 1106 while(len--) { 1107 switch(*p) { 1108 case '\\': 1109 case '"': 1110 s = sdscatprintf(s,"\\%c",*p); 1111 break; 1112 case '\n': s = sdscatlen(s,"\\n",2); break; 1113 case '\r': s = sdscatlen(s,"\\r",2); break; 1114 case '\t': s = sdscatlen(s,"\\t",2); break; 1115 case '\a': s = sdscatlen(s,"\\a",2); break; 1116 case '\b': s = sdscatlen(s,"\\b",2); break; 1117 default: 1118 if (isprint(*p)) 1119 s = sdscatprintf(s,"%c",*p); 1120 else 1121 s = sdscatprintf(s,"\\x%02x",(unsigned char)*p); 1122 break; 1123 } 1124 p++; 1125 } 1126 1127 return sdscatlen(s,"\"",1); 1128 } 1129 1130 /* Helper function for sdssplitargs() that returns non zero if 'c' 1131 * is a valid hex digit. */ 1132 /* 1133 * 如果 c 为十六进制符号的其中一个，返回正数 1134 * 1135 * T = O(1) 1136 */ 1137 int is_hex_digit(char c) { 1138 return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || 1139 (c >= 'A' && c <= 'F'); 1140 } 1141 1142 /* Helper function for sdssplitargs() that converts a hex digit into an 1143 * integer from 0 to 15 */ 1144 /* 1145 * 将十六进制符号转换为 10 进制 1146 * 1147 * T = O(1) 1148 */ 1149 int hex_digit_to_int(char c) { 1150 switch(c) { 1151 case '0': return 0; 1152 case '1': return 1; 1153 case '2': return 2; 1154 case '3': return 3; 1155 case '4': return 4; 1156 case '5': return 5; 1157 case '6': return 6; 1158 case '7': return 7; 1159 case '8': return 8; 1160 case '9': return 9; 1161 case 'a': case 'A': return 10; 1162 case 'b': case 'B': return 11; 1163 case 'c': case 'C': return 12; 1164 case 'd': case 'D': return 13; 1165 case 'e': case 'E': return 14; 1166 case 'f': case 'F': return 15; 1167 default: return 0; 1168 } 1169 } 1170 1171 /* Split a line into arguments, where every argument can be in the 1172 * following programming-language REPL-alike form: 1173 * 1174 * 将一行文本分割成多个参数，每个参数可以有以下的类编程语言 REPL 格式： 1175 * 1176 * foo bar "newline are supported\n" and "\xff\x00otherstuff" 1177 * 1178 * The number of arguments is stored into *argc, and an array 1179 * of sds is returned. 1180 * 1181 * 参数的个数会保存在 *argc 中，函数返回一个 sds 数组。 1182 * 1183 * The caller should free the resulting array of sds strings with 1184 * sdsfreesplitres(). 1185 * 1186 * 调用者应该使用 sdsfreesplitres() 来释放函数返回的 sds 数组。 1187 * 1188 * Note that sdscatrepr() is able to convert back a string into 1189 * a quoted string in the same format sdssplitargs() is able to parse. 1190 * 1191 * sdscatrepr() 可以将一个字符串转换为一个带引号（quoted）的字符串， 1192 * 这个带引号的字符串可以被 sdssplitargs() 分析。 1193 * 1194 * The function returns the allocated tokens on success, even when the 1195 * input string is empty, or NULL if the input contains unbalanced 1196 * quotes or closed quotes followed by non space characters 1197 * as in: "foo"bar or "foo' 1198 * 1199 * 即使输入出现空字符串， NULL ，或者输入带有未对应的括号， 1200 * 函数都会将已成功处理的字符串先返回。 1201 * 1202 * 这个函数主要用于 config.c 中对配置文件进行分析。 1203 * 例子： 1204 * sds *arr = sdssplitargs("timeout 10086\r\nport 123321\r\n"); 1205 * 会得出 1206 * arr[0] = "timeout" 1207 * arr[1] = "10086" 1208 * arr[2] = "port" 1209 * arr[3] = "123321" 1210 * 1211 * T = O(N^2) 1212 */ 1213 sds *sdssplitargs(const char *line, int *argc) { 1214 const char *p = line; 1215 char *current = NULL; 1216 char **vector = NULL; 1217 1218 *argc = 0; 1219 while(1) { 1220 1221 /* skip blanks */ 1222 // 跳过空白 1223 // T = O(N) 1224 while(*p && isspace(*p)) p++; 1225 1226 if (*p) { 1227 /* get a token */ 1228 int inq=0; /* set to 1 if we are in "quotes" */ 1229 int insq=0; /* set to 1 if we are in 'single quotes' */ 1230 int done=0; 1231 1232 if (current == NULL) current = sdsempty(); 1233 1234 // T = O(N) 1235 while(!done) { 1236 if (inq) { 1237 if (*p == '\\' && *(p+1) == 'x' && 1238 is_hex_digit(*(p+2)) && 1239 is_hex_digit(*(p+3))) 1240 { 1241 unsigned char byte; 1242 1243 byte = (hex_digit_to_int(*(p+2))*16)+ 1244 hex_digit_to_int(*(p+3)); 1245 current = sdscatlen(current,(char*)&byte,1); 1246 p += 3; 1247 } else if (*p == '\\' && *(p+1)) { 1248 char c; 1249 1250 p++; 1251 switch(*p) { 1252 case 'n': c = '\n'; break; 1253 case 'r': c = '\r'; break; 1254 case 't': c = '\t'; break; 1255 case 'b': c = '\b'; break; 1256 case 'a': c = '\a'; break; 1257 default: c = *p; break; 1258 } 1259 current = sdscatlen(current,&c,1); 1260 } else if (*p == '"') { 1261 /* closing quote must be followed by a space or 1262 * nothing at all. */ 1263 if (*(p+1) && !isspace(*(p+1))) goto err; 1264 done=1; 1265 } else if (!*p) { 1266 /* unterminated quotes */ 1267 goto err; 1268 } else { 1269 current = sdscatlen(current,p,1); 1270 } 1271 } else if (insq) { 1272 if (*p == '\\' && *(p+1) == '\'') { 1273 p++; 1274 current = sdscatlen(current,"'",1); 1275 } else if (*p == '\'') { 1276 /* closing quote must be followed by a space or 1277 * nothing at all. */ 1278 if (*(p+1) && !isspace(*(p+1))) goto err; 1279 done=1; 1280 } else if (!*p) { 1281 /* unterminated quotes */ 1282 goto err; 1283 } else { 1284 current = sdscatlen(current,p,1); 1285 } 1286 } else { 1287 switch(*p) { 1288 case ' ': 1289 case '\n': 1290 case '\r': 1291 case '\t': 1292 case '\0': 1293 done=1; 1294 break; 1295 case '"': 1296 inq=1; 1297 break; 1298 case '\'': 1299 insq=1; 1300 break; 1301 default: 1302 current = sdscatlen(current,p,1); 1303 break; 1304 } 1305 } 1306 if (*p) p++; 1307 } 1308 /* add the token to the vector */ 1309 // T = O(N) 1310 vector = zrealloc(vector,((*argc)+1)*sizeof(char*)); 1311 vector[*argc] = current; 1312 (*argc)++; 1313 current = NULL; 1314 } else { 1315 /* Even on empty input string return something not NULL. */ 1316 if (vector == NULL) vector = zmalloc(sizeof(void*)); 1317 return vector; 1318 } 1319 } 1320 1321 err: 1322 while((*argc)--) 1323 sdsfree(vector[*argc]); 1324 zfree(vector); 1325 if (current) sdsfree(current); 1326 *argc = 0; 1327 return NULL; 1328 } 1329 1330 /* Modify the string substituting all the occurrences of the set of 1331 * characters specified in the 'from' string to the corresponding character 1332 * in the 'to' array. 1333 * 1334 * 将字符串 s 中， 1335 * 所有在 from 中出现的字符，替换成 to 中的字符 1336 * 1337 * For instance: sdsmapchars(mystring, "ho", "01", 2) 1338 * will have the effect of turning the string "hello" into "0ell1". 1339 * 1340 * 比如调用 sdsmapchars(mystring, "ho", "01", 2) 1341 * 就会将 "hello" 转换为 "0ell1" 1342 * 1343 * The function returns the sds string pointer, that is always the same 1344 * as the input pointer since no resize is needed. 1345 * 因为无须对 sds 进行大小调整， 1346 * 所以返回的 sds 输入的 sds 一样 1347 * 1348 * T = O(N^2) 1349 */ 1350 sds sdsmapchars(sds s, const char *from, const char *to, size_t setlen) { 1351 size_t j, i, l = sdslen(s); 1352 1353 // 遍历输入字符串 1354 for (j = 0; j < l; j++) { 1355 // 遍历映射 1356 for (i = 0; i < setlen; i++) { 1357 // 替换字符串 1358 if (s[j] == from[i]) { 1359 s[j] = to[i]; 1360 break; 1361 } 1362 } 1363 } 1364 return s; 1365 } 1366 1367 /* Join an array of C strings using the specified separator (also a C string). 1368 * Returns the result as an sds string. */ 1369 sds sdsjoin(char **argv, int argc, char *sep) { 1370 sds join = sdsempty(); 1371 int j; 1372 1373 for (j = 0; j < argc; j++) { 1374 join = sdscat(join, argv[j]); 1375 if (j != argc-1) join = sdscat(join,sep); 1376 } 1377 return join; 1378 } 1379 1380 #ifdef SDS_TEST_MAIN 1381 #include <stdio.h> 1382 #include "testhelp.h" 1383 #include "limits.h" 1384 1385 int main(void) { 1386 { 1387 struct sdshdr *sh; 1388 sds x = sdsnew("foo"), y; 1389 1390 test_cond("Create a string and obtain the length", 1391 sdslen(x) == 3 && memcmp(x,"foo\0",4) == 0) 1392 1393 sdsfree(x); 1394 x = sdsnewlen("foo",2); 1395 test_cond("Create a string with specified length", 1396 sdslen(x) == 2 && memcmp(x,"fo\0",3) == 0) 1397 1398 x = sdscat(x,"bar"); 1399 test_cond("Strings concatenation", 1400 sdslen(x) == 5 && memcmp(x,"fobar\0",6) == 0); 1401 1402 x = sdscpy(x,"a"); 1403 test_cond("sdscpy() against an originally longer string", 1404 sdslen(x) == 1 && memcmp(x,"a\0",2) == 0) 1405 1406 x = sdscpy(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk"); 1407 test_cond("sdscpy() against an originally shorter string", 1408 sdslen(x) == 33 && 1409 memcmp(x,"xyzxxxxxxxxxxyyyyyyyyyykkkkkkkkkk\0",33) == 0) 1410 1411 sdsfree(x); 1412 x = sdscatprintf(sdsempty(),"%d",123); 1413 test_cond("sdscatprintf() seems working in the base case", 1414 sdslen(x) == 3 && memcmp(x,"123\0",4) == 0) 1415 1416 sdsfree(x); 1417 x = sdsnew("--"); 1418 x = sdscatfmt(x, "Hello %s World %I,%I--", "Hi!", LLONG_MIN,LLONG_MAX); 1419 test_cond("sdscatfmt() seems working in the base case", 1420 sdslen(x) == 60 && 1421 memcmp(x,"--Hello Hi! World -9223372036854775808," 1422 "9223372036854775807--",60) == 0) 1423 1424 sdsfree(x); 1425 x = sdsnew("--"); 1426 x = sdscatfmt(x, "%u,%U--", UINT_MAX, ULLONG_MAX); 1427 test_cond("sdscatfmt() seems working with unsigned numbers", 1428 sdslen(x) == 35 && 1429 memcmp(x,"--4294967295,18446744073709551615--",35) == 0) 1430 1431 sdsfree(x); 1432 x = sdsnew("xxciaoyyy"); 1433 sdstrim(x,"xy"); 1434 test_cond("sdstrim() correctly trims characters", 1435 sdslen(x) == 4 && memcmp(x,"ciao\0",5) == 0) 1436 1437 y = sdsdup(x); 1438 sdsrange(y,1,1); 1439 test_cond("sdsrange(...,1,1)", 1440 sdslen(y) == 1 && memcmp(y,"i\0",2) == 0) 1441 1442 sdsfree(y); 1443 y = sdsdup(x); 1444 sdsrange(y,1,-1); 1445 test_cond("sdsrange(...,1,-1)", 1446 sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) 1447 1448 sdsfree(y); 1449 y = sdsdup(x); 1450 sdsrange(y,-2,-1); 1451 test_cond("sdsrange(...,-2,-1)", 1452 sdslen(y) == 2 && memcmp(y,"ao\0",3) == 0) 1453 1454 sdsfree(y); 1455 y = sdsdup(x); 1456 sdsrange(y,2,1); 1457 test_cond("sdsrange(...,2,1)", 1458 sdslen(y) == 0 && memcmp(y,"\0",1) == 0) 1459 1460 sdsfree(y); 1461 y = sdsdup(x); 1462 sdsrange(y,1,100); 1463 test_cond("sdsrange(...,1,100)", 1464 sdslen(y) == 3 && memcmp(y,"iao\0",4) == 0) 1465 1466 sdsfree(y); 1467 y = sdsdup(x); 1468 sdsrange(y,100,100); 1469 test_cond("sdsrange(...,100,100)", 1470 sdslen(y) == 0 && memcmp(y,"\0",1) == 0) 1471 1472 sdsfree(y); 1473 sdsfree(x); 1474 x = sdsnew("foo"); 1475 y = sdsnew("foa"); 1476 test_cond("sdscmp(foo,foa)", sdscmp(x,y) > 0) 1477 1478 sdsfree(y); 1479 sdsfree(x); 1480 x = sdsnew("bar"); 1481 y = sdsnew("bar"); 1482 test_cond("sdscmp(bar,bar)", sdscmp(x,y) == 0) 1483 1484 sdsfree(y); 1485 sdsfree(x); 1486 x = sdsnew("aar"); 1487 y = sdsnew("bar"); 1488 test_cond("sdscmp(bar,bar)", sdscmp(x,y) < 0) 1489 1490 sdsfree(y); 1491 sdsfree(x); 1492 x = sdsnewlen("\a\n\0foo\r",7); 1493 y = sdscatrepr(sdsempty(),x,sdslen(x)); 1494 test_cond("sdscatrepr(...data...)", 1495 memcmp(y,"\"\\a\\n\\x00foo\\r\"",15) == 0) 1496 1497 { 1498 int oldfree; 1499 1500 sdsfree(x); 1501 x = sdsnew("0"); 1502 sh = (void*) (x-(sizeof(struct sdshdr))); 1503 test_cond("sdsnew() free/len buffers", sh->len == 1 && sh->free == 0); 1504 x = sdsMakeRoomFor(x,1); 1505 sh = (void*) (x-(sizeof(struct sdshdr))); 1506 test_cond("sdsMakeRoomFor()", sh->len == 1 && sh->free > 0); 1507 oldfree = sh->free; 1508 x[1] = '1'; 1509 sdsIncrLen(x,1); 1510 test_cond("sdsIncrLen() -- content", x[0] == '0' && x[1] == '1'); 1511 test_cond("sdsIncrLen() -- len", sh->len == 2); 1512 test_cond("sdsIncrLen() -- free", sh->free == oldfree-1); 1513 } 1514 } 1515 test_report() 1516 return 0; 1517 } 1518 #endif
3049
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
