开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
varchar.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：16k
源码类别：

数据库系统

开发平台：

Unix_Linux

varchar.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * varchar.c
  4.  *   Functions for the built-in type char() and varchar().
  5.  *
  6.  * Copyright (c) 1994, Regents of the University of California
  7.  *
  8.  *
  9.  * IDENTIFICATION
  10.  *   $Header: /usr/local/cvsroot/pgsql/src/backend/utils/adt/varchar.c,v 1.48.2.1 1999/08/02 05:24:58 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  15. #include "postgres.h"
  16. #include "access/htup.h"
  17. #include "catalog/pg_type.h"
  18. #include "utils/builtins.h"
  20. #ifdef MULTIBYTE
  21. #include "mb/pg_wchar.h"
  22. #endif
  24. #ifdef CYR_RECODE
  25. char    *convertstr(char *, int, int);
  26. #endif
  29. /*
  30.  * CHAR() and VARCHAR() types are part of the ANSI SQL standard. CHAR()
  31.  * is for blank-padded string whose length is specified in CREATE TABLE.
  32.  * VARCHAR is for storing string whose length is at most the length specified
  33.  * at CREATE TABLE time.
  34.  *
  35.  * It's hard to implement these types because we cannot figure out what
  36.  * the length of the type from the type itself. I change (hopefully all) the
  37.  * fmgr calls that invoke input functions of a data type to supply the
  38.  * length also. (eg. in INSERTs, we have the tupleDescriptor which contains
  39.  * the length of the attributes and hence the exact length of the char() or
  40.  * varchar(). We pass this to bpcharin() or varcharin().) In the case where
  41.  * we cannot determine the length, we pass in -1 instead and the input string
  42.  * must be null-terminated.
  43.  *
  44.  * We actually implement this as a varlena so that we don't have to pass in
  45.  * the length for the comparison functions. (The difference between "text"
  46.  * is that we truncate and possibly blank-pad the string at insertion time.)
  47.  *
  48.  *   - ay 6/95
  49.  */
  52. /*****************************************************************************
  53.  *  bpchar - char()  *
  54.  *****************************************************************************/
  56. /*
  57.  * bpcharin -
  58.  *   converts a string of char() type to the internal representation.
  59.  *   len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here
  60.  *   because we pass typelem as the second argument for array_in.)
  61.  */
  62. char *
  63. bpcharin(char *s, int dummy, int32 atttypmod)
  64. {
  65. char    *result,
  66.    *r;
  67. int len;
  68. int i;
  70. if (s == NULL)
  71. return (char *) NULL;
  73. if (atttypmod == -1)
  74. {
  76. /*
  77.  * this is here because some functions can't supply the atttypmod
  78.  */
  79. len = strlen(s);
  80. atttypmod = len + VARHDRSZ;
  81. }
  82. else
  83. len = atttypmod - VARHDRSZ;
  85. if (len > MaxAttrSize)
  86. elog(ERROR, "bpcharin: length of char() must be less than %d",
  87. MaxAttrSize);
  89. result = (char *) palloc(atttypmod);
  90. VARSIZE(result) = atttypmod;
  91. r = VARDATA(result);
  92. for (i = 0; i < len; i++, r++, s++)
  93. {
  94. *r = *s;
  95. if (*r == '')
  96. break;
  97. }
  99. #ifdef CYR_RECODE
  100. convertstr(result + VARHDRSZ, len, 0);
  101. #endif
  103. /* blank pad the string if necessary */
  104. for (; i < len; i++)
  105. *r++ = ' ';
  106. return result;
  107. }
  109. char *
  110. bpcharout(char *s)
  111. {
  112. char    *result;
  113. int len;
  115. if (s == NULL)
  116. {
  117. result = (char *) palloc(2);
  118. result[0] = '-';
  119. result[1] = '';
  120. }
  121. else
  122. {
  123. len = VARSIZE(s) - VARHDRSZ;
  124. result = (char *) palloc(len + 1);
  125. StrNCpy(result, VARDATA(s), len + 1); /* these are blank-padded */
  126. }
  128. #ifdef CYR_RECODE
  129. convertstr(result, len, 1);
  130. #endif
  132. return result;
  133. }
  135. /* bpchar()
  136.  * Converts a char() type to a specific internal length.
  137.  * len is the length specified in () plus VARHDRSZ bytes.
  138.  */
  139. char *
  140. bpchar(char *s, int32 len)
  141. {
  142. char    *result,
  143.    *r;
  144. int rlen,
  145. slen;
  146. int i;
  148. if (s == NULL)
  149. return (char *) NULL;
  151. if ((len == -1) || (len == VARSIZE(s)))
  152. return s;
  154. rlen = len - VARHDRSZ;
  156. if (rlen > MaxAttrSize)
  157. elog(ERROR, "bpchar: length of char() must be less than %d",
  158. MaxAttrSize);
  160. #ifdef STRINGDEBUG
  161. printf("bpchar- convert string length %d (%d) ->%d (%d)n",
  162.    VARSIZE(s) - VARHDRSZ, VARSIZE(s), rlen, len);
  163. #endif
  165. result = (char *) palloc(len);
  166. VARSIZE(result) = len;
  167. r = VARDATA(result);
  168. #ifdef MULTIBYTE
  170. /*
  171.  * truncate multi-byte string in a way not to break multi-byte
  172.  * boundary
  173.  */
  174. if (VARSIZE(s) > len)
  175. slen = pg_mbcliplen(VARDATA(s), VARSIZE(s) - VARHDRSZ, rlen);
  176. else
  177. slen = VARSIZE(s) - VARHDRSZ;
  178. #else
  179. slen = VARSIZE(s) - VARHDRSZ;
  180. #endif
  181. s = VARDATA(s);
  183. #ifdef STRINGDEBUG
  184. printf("bpchar- string is '");
  185. #endif
  187. for (i = 0; (i < rlen) && (i < slen); i++)
  188. {
  189. if (*s == '')
  190. break;
  192. #ifdef STRINGDEBUG
  193. printf("%c", *s);
  194. #endif
  196. *r++ = *s++;
  197. }
  199. #ifdef STRINGDEBUG
  200. printf("'n");
  201. #endif
  203. /* blank pad the string if necessary */
  204. for (; i < rlen; i++)
  205. *r++ = ' ';
  207. return result;
  208. } /* bpchar() */
  210. /* _bpchar()
  211.  * Converts an array of char() type to a specific internal length.
  212.  * len is the length specified in () plus VARHDRSZ bytes.
  213.  */
  214. ArrayType  *
  215. _bpchar(ArrayType *v, int32 len)
  216. {
  217. return array_map(v, BPCHAROID, bpchar, BPCHAROID, 1, len);
  218. }
  221. /* bpchar_char()
  222.  * Convert bpchar(1) to char.
  223.  */
  224. int32
  225. bpchar_char(char *s)
  226. {
  227. return (int32) *VARDATA(s);
  228. } /* bpchar_char() */
  230. /* char_bpchar()
  231.  * Convert char to bpchar(1).
  232.  */
  233. char *
  234. char_bpchar(int32 c)
  235. {
  236. char    *result;
  238. result = palloc(VARHDRSZ + 1);
  240. VARSIZE(result) = VARHDRSZ + 1;
  241. *(VARDATA(result)) = (char) c;
  243. return result;
  244. } /* char_bpchar() */
  247. /* bpchar_name()
  248.  * Converts a bpchar() type to a NameData type.
  249.  */
  250. NameData   *
  251. bpchar_name(char *s)
  252. {
  253. NameData   *result;
  254. int len;
  256. if (s == NULL)
  257. return NULL;
  259. len = VARSIZE(s) - VARHDRSZ;
  260. if (len > NAMEDATALEN)
  261. len = NAMEDATALEN;
  263. while (len > 0)
  264. {
  265. if (*(VARDATA(s) + len - 1) != ' ')
  266. break;
  267. len--;
  268. }
  270. #ifdef STRINGDEBUG
  271. printf("bpchar- convert string length %d (%d) ->%dn",
  272.    VARSIZE(s) - VARHDRSZ, VARSIZE(s), len);
  273. #endif
  275. result = (NameData *) palloc(NAMEDATALEN);
  276. StrNCpy(result->data, VARDATA(s), NAMEDATALEN);
  278. /* now null pad to full length... */
  279. while (len < NAMEDATALEN)
  280. {
  281. *(result->data + len) = '';
  282. len++;
  283. }
  285. return result;
  286. } /* bpchar_name() */
  288. /* name_bpchar()
  289.  * Converts a NameData type to a bpchar type.
  290.  */
  291. char *
  292. name_bpchar(NameData *s)
  293. {
  294. char    *result;
  295. int len;
  297. if (s == NULL)
  298. return NULL;
  300. len = strlen(s->data);
  302. #ifdef STRINGDEBUG
  303. printf("bpchar- convert string length %d (%d) ->%dn",
  304.    VARSIZE(s) - VARHDRSZ, VARSIZE(s), len);
  305. #endif
  307. result = (char *) palloc(VARHDRSZ + len);
  308. strncpy(VARDATA(result), s->data, len);
  309. VARSIZE(result) = len + VARHDRSZ;
  311. return result;
  312. } /* name_bpchar() */
  315. /*****************************************************************************
  316.  *  varchar - varchar()  *
  317.  *****************************************************************************/
  319. /*
  320.  * varcharin -
  321.  *   converts a string of varchar() type to the internal representation.
  322.  *   len is the length specified in () plus VARHDRSZ bytes. (XXX dummy is here
  323.  *   because we pass typelem as the second argument for array_in.)
  324.  */
  325. char *
  326. varcharin(char *s, int dummy, int32 atttypmod)
  327. {
  328. char    *result;
  329. int len;
  331. if (s == NULL)
  332. return (char *) NULL;
  334. len = strlen(s) + VARHDRSZ;
  335. if (atttypmod != -1 && len > atttypmod)
  336. len = atttypmod; /* clip the string at max length */
  338. if (len > MaxAttrSize)
  339. elog(ERROR, "varcharin: length of char() must be less than %d",
  340. MaxAttrSize);
  342. result = (char *) palloc(len);
  343. VARSIZE(result) = len;
  344. strncpy(VARDATA(result), s, len - VARHDRSZ);
  346. #ifdef CYR_RECODE
  347. convertstr(result + VARHDRSZ, len, 0);
  348. #endif
  350. return result;
  351. }
  353. char *
  354. varcharout(char *s)
  355. {
  356. char    *result;
  357. int len;
  359. if (s == NULL)
  360. {
  361. result = (char *) palloc(2);
  362. result[0] = '-';
  363. result[1] = '';
  364. }
  365. else
  366. {
  367. len = VARSIZE(s) - VARHDRSZ;
  368. result = (char *) palloc(len + 1);
  369. StrNCpy(result, VARDATA(s), len + 1);
  370. }
  372. #ifdef CYR_RECODE
  373. convertstr(result, len, 1);
  374. #endif
  376. return result;
  377. }
  379. /* varchar()
  380.  * Converts a varchar() type to the specified size.
  381.  * slen is the length specified in () plus VARHDRSZ bytes.
  382.  */
  383. char *
  384. varchar(char *s, int32 slen)
  385. {
  386. char    *result;
  387. int len;
  389. if (s == NULL)
  390. return (char *) NULL;
  392. len = VARSIZE(s);
  393. if ((slen == -1) || (len <= slen))
  394. return (char *) s;
  396. /* only reach here if we need to truncate string... */
  398. #ifdef MULTIBYTE
  400. /*
  401.  * truncate multi-byte string in a way not to break multi-byte
  402.  * boundary
  403.  */
  404. len = pg_mbcliplen(VARDATA(s), slen - VARHDRSZ, slen - VARHDRSZ);
  405. slen = len + VARHDRSZ;
  406. #else
  407. len = slen - VARHDRSZ;
  408. #endif
  410. if (len > MaxAttrSize)
  411. elog(ERROR, "varchar: length of varchar() must be less than %d",
  412. MaxAttrSize);
  414. result = (char *) palloc(slen);
  415. VARSIZE(result) = slen;
  416. strncpy(VARDATA(result), VARDATA(s), len);
  418. return result;
  419. } /* varchar() */
  421. /* _varchar()
  422.  * Converts an array of varchar() type to the specified size.
  423.  * len is the length specified in () plus VARHDRSZ bytes.
  424.  */
  425. ArrayType  *
  426. _varchar(ArrayType *v, int32 len)
  427. {
  428. return array_map(v, VARCHAROID, varchar, VARCHAROID, 1, len);
  429. }
  432. /*****************************************************************************
  433.  * Comparison Functions used for bpchar
  434.  *****************************************************************************/
  436. static int
  437. bcTruelen(char *arg)
  438. {
  439. char    *s = VARDATA(arg);
  440. int i;
  441. int len;
  443. len = VARSIZE(arg) - VARHDRSZ;
  444. for (i = len - 1; i >= 0; i--)
  445. {
  446. if (s[i] != ' ')
  447. break;
  448. }
  449. return i + 1;
  450. }
  452. int32
  453. bpcharlen(char *arg)
  454. {
  455. #ifdef MULTIBYTE
  456. unsigned char *s;
  457. int len,
  458. l,
  459. wl;
  461. #endif
  462. if (!PointerIsValid(arg))
  463. elog(ERROR, "Bad (null) char() external representation", NULL);
  464. #ifdef MULTIBYTE
  465. l = bcTruelen(arg);
  466. len = 0;
  467. s = VARDATA(arg);
  468. while (l > 0)
  469. {
  470. wl = pg_mblen(s);
  471. l -= wl;
  472. s += wl;
  473. len++;
  474. }
  475. return (len);
  476. #else
  477. return bcTruelen(arg);
  478. #endif
  479. }
  481. int32
  482. bpcharoctetlen(char *arg)
  483. {
  484. if (!PointerIsValid(arg))
  485. elog(ERROR, "Bad (null) char() external representation", NULL);
  487. return bcTruelen(arg);
  488. }
  490. bool
  491. bpchareq(char *arg1, char *arg2)
  492. {
  493. int len1,
  494. len2;
  496. if (arg1 == NULL || arg2 == NULL)
  497. return (bool) 0;
  498. len1 = bcTruelen(arg1);
  499. len2 = bcTruelen(arg2);
  501. if (len1 != len2)
  502. return 0;
  504. return strncmp(VARDATA(arg1), VARDATA(arg2), len1) == 0;
  505. }
  507. bool
  508. bpcharne(char *arg1, char *arg2)
  509. {
  510. int len1,
  511. len2;
  513. if (arg1 == NULL || arg2 == NULL)
  514. return (bool) 0;
  515. len1 = bcTruelen(arg1);
  516. len2 = bcTruelen(arg2);
  518. if (len1 != len2)
  519. return 1;
  521. return strncmp(VARDATA(arg1), VARDATA(arg2), len1) != 0;
  522. }
  524. bool
  525. bpcharlt(char *arg1, char *arg2)
  526. {
  527. int len1,
  528. len2;
  529. int cmp;
  531. if (arg1 == NULL || arg2 == NULL)
  532. return (bool) 0;
  533. len1 = bcTruelen(arg1);
  534. len2 = bcTruelen(arg2);
  536. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  537. if (cmp == 0)
  538. return len1 < len2;
  539. else
  540. return cmp < 0;
  541. }
  543. bool
  544. bpcharle(char *arg1, char *arg2)
  545. {
  546. int len1,
  547. len2;
  548. int cmp;
  550. if (arg1 == NULL || arg2 == NULL)
  551. return (bool) 0;
  552. len1 = bcTruelen(arg1);
  553. len2 = bcTruelen(arg2);
  555. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  556. if (0 == cmp)
  557. return (bool) (len1 <= len2 ? 1 : 0);
  558. else
  559. return (bool) (cmp <= 0);
  560. }
  562. bool
  563. bpchargt(char *arg1, char *arg2)
  564. {
  565. int len1,
  566. len2;
  567. int cmp;
  569. if (arg1 == NULL || arg2 == NULL)
  570. return (bool) 0;
  571. len1 = bcTruelen(arg1);
  572. len2 = bcTruelen(arg2);
  574. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  575. if (cmp == 0)
  576. return len1 > len2;
  577. else
  578. return cmp > 0;
  579. }
  581. bool
  582. bpcharge(char *arg1, char *arg2)
  583. {
  584. int len1,
  585. len2;
  586. int cmp;
  588. if (arg1 == NULL || arg2 == NULL)
  589. return (bool) 0;
  590. len1 = bcTruelen(arg1);
  591. len2 = bcTruelen(arg2);
  593. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  594. if (0 == cmp)
  595. return (bool) (len1 >= len2 ? 1 : 0);
  596. else
  597. return (bool) (cmp >= 0);
  598. }
  600. int32
  601. bpcharcmp(char *arg1, char *arg2)
  602. {
  603. int len1,
  604. len2;
  605. int cmp;
  607. len1 = bcTruelen(arg1);
  608. len2 = bcTruelen(arg2);
  610. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  611. if ((0 == cmp) && (len1 != len2))
  612. return (int32) (len1 < len2 ? -1 : 1);
  613. else
  614. return cmp;
  615. }
  617. /*****************************************************************************
  618.  * Comparison Functions used for varchar
  619.  *****************************************************************************/
  621. int32
  622. varcharlen(char *arg)
  623. {
  624. #ifdef MULTIBYTE
  625. unsigned char *s;
  626. int len,
  627. l,
  628. wl;
  630. #endif
  631. if (!PointerIsValid(arg))
  632. elog(ERROR, "Bad (null) varchar() external representation", NULL);
  634. #ifdef MULTIBYTE
  635. len = 0;
  636. s = VARDATA(arg);
  637. l = VARSIZE(arg) - VARHDRSZ;
  638. while (l > 0)
  639. {
  640. wl = pg_mblen(s);
  641. l -= wl;
  642. s += wl;
  643. len++;
  644. }
  645. return (len);
  646. #else
  647. return VARSIZE(arg) - VARHDRSZ;
  648. #endif
  649. }
  651. int32
  652. varcharoctetlen(char *arg)
  653. {
  654. if (!PointerIsValid(arg))
  655. elog(ERROR, "Bad (null) varchar() external representation", NULL);
  656. return VARSIZE(arg) - VARHDRSZ;
  657. }
  659. bool
  660. varchareq(char *arg1, char *arg2)
  661. {
  662. int len1,
  663. len2;
  665. if (arg1 == NULL || arg2 == NULL)
  666. return (bool) 0;
  668. len1 = VARSIZE(arg1) - VARHDRSZ;
  669. len2 = VARSIZE(arg2) - VARHDRSZ;
  671. if (len1 != len2)
  672. return 0;
  674. return strncmp(VARDATA(arg1), VARDATA(arg2), len1) == 0;
  675. }
  677. bool
  678. varcharne(char *arg1, char *arg2)
  679. {
  680. int len1,
  681. len2;
  683. if (arg1 == NULL || arg2 == NULL)
  684. return (bool) 0;
  685. len1 = VARSIZE(arg1) - VARHDRSZ;
  686. len2 = VARSIZE(arg2) - VARHDRSZ;
  688. if (len1 != len2)
  689. return 1;
  691. return strncmp(VARDATA(arg1), VARDATA(arg2), len1) != 0;
  692. }
  694. bool
  695. varcharlt(char *arg1, char *arg2)
  696. {
  697. int len1,
  698. len2;
  699. int cmp;
  701. if (arg1 == NULL || arg2 == NULL)
  702. return (bool) 0;
  703. len1 = VARSIZE(arg1) - VARHDRSZ;
  704. len2 = VARSIZE(arg2) - VARHDRSZ;
  706. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  707. if (cmp == 0)
  708. return len1 < len2;
  709. else
  710. return cmp < 0;
  711. }
  713. bool
  714. varcharle(char *arg1, char *arg2)
  715. {
  716. int len1,
  717. len2;
  718. int cmp;
  720. if (arg1 == NULL || arg2 == NULL)
  721. return (bool) 0;
  722. len1 = VARSIZE(arg1) - VARHDRSZ;
  723. len2 = VARSIZE(arg2) - VARHDRSZ;
  725. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  726. if (0 == cmp)
  727. return (bool) (len1 <= len2 ? 1 : 0);
  728. else
  729. return (bool) (cmp <= 0);
  730. }
  732. bool
  733. varchargt(char *arg1, char *arg2)
  734. {
  735. int len1,
  736. len2;
  737. int cmp;
  739. if (arg1 == NULL || arg2 == NULL)
  740. return (bool) 0;
  741. len1 = VARSIZE(arg1) - VARHDRSZ;
  742. len2 = VARSIZE(arg2) - VARHDRSZ;
  744. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  745. if (cmp == 0)
  746. return len1 > len2;
  747. else
  748. return cmp > 0;
  749. }
  751. bool
  752. varcharge(char *arg1, char *arg2)
  753. {
  754. int len1,
  755. len2;
  756. int cmp;
  758. if (arg1 == NULL || arg2 == NULL)
  759. return (bool) 0;
  760. len1 = VARSIZE(arg1) - VARHDRSZ;
  761. len2 = VARSIZE(arg2) - VARHDRSZ;
  763. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  764. if (0 == cmp)
  765. return (bool) (len1 >= len2 ? 1 : 0);
  766. else
  767. return (bool) (cmp >= 0);
  769. }
  771. int32
  772. varcharcmp(char *arg1, char *arg2)
  773. {
  774. int len1,
  775. len2;
  776. int cmp;
  778. len1 = VARSIZE(arg1) - VARHDRSZ;
  779. len2 = VARSIZE(arg2) - VARHDRSZ;
  780. cmp = varstr_cmp(VARDATA(arg1), len1, VARDATA(arg2), len2);
  781. if ((0 == cmp) && (len1 != len2))
  782. return (int32) (len1 < len2 ? -1 : 1);
  783. else
  784. return (int32) (cmp);
  785. }
  787. /*****************************************************************************
  788.  * Hash functions (modified from hashtext in access/hash/hashfunc.c)
  789.  *****************************************************************************/
  791. uint32
  792. hashbpchar(struct varlena * key)
  793. {
  794. int keylen;
  795. char    *keydata;
  796. uint32 n;
  797. int loop;
  799. keydata = VARDATA(key);
  800. keylen = bcTruelen((char *) key);
  802. #define HASHC n = *keydata++ + 65599 * n
  804. n = 0;
  805. if (keylen > 0)
  806. {
  807. loop = (keylen + 8 - 1) >> 3;
  809. switch (keylen & (8 - 1))
  810. {
  811. case 0:
  812. do
  813. { /* All fall throughs */
  814. HASHC;
  815. case 7:
  816. HASHC;
  817. case 6:
  818. HASHC;
  819. case 5:
  820. HASHC;
  821. case 4:
  822. HASHC;
  823. case 3:
  824. HASHC;
  825. case 2:
  826. HASHC;
  827. case 1:
  828. HASHC;
  829. } while (--loop);
  830. }
  831. }
  832. return n;
  833. }
  835. uint32
  836. hashvarchar(struct varlena * key)
  837. {
  838. int keylen;
  839. char    *keydata;
  840. uint32 n;
  841. int loop;
  843. keydata = VARDATA(key);
  844. keylen = VARSIZE(key) - VARHDRSZ;
  846. #define HASHC n = *keydata++ + 65599 * n
  848. n = 0;
  849. if (keylen > 0)
  850. {
  851. loop = (keylen + 8 - 1) >> 3;
  853. switch (keylen & (8 - 1))
  854. {
  855. case 0:
  856. do
  857. { /* All fall throughs */
  858. HASHC;
  859. case 7:
  860. HASHC;
  861. case 6:
  862. HASHC;
  863. case 5:
  864. HASHC;
  865. case 4:
  866. HASHC;
  867. case 3:
  868. HASHC;
  869. case 2:
  870. HASHC;
  871. case 1:
  872. HASHC;
  873. } while (--loop);
  874. }
  875. }
  876. return n;
  877. }