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

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

数据库系统

开发平台：

Unix_Linux

int.c：源码内容
  1. /*-------------------------------------------------------------------------
  2.  *
  3.  * int.c
  4.  *   Functions for the built-in integer types.
  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/int.c,v 1.21.2.1 1999/08/02 05:24:53 scrappy Exp $
  11.  *
  12.  *-------------------------------------------------------------------------
  13.  */
  14. /*
  15.  * OLD COMMENTS
  16.  * I/O routines:
  17.  *  int2in, int2out, int28in, int28out, int4in, int4out
  18.  * Conversion routines:
  19.  *  itoi, int2_text, int4_text
  20.  * Boolean operators:
  21.  *  inteq, intne, intlt, intle, intgt, intge
  22.  * Arithmetic operators:
  23.  *  intpl, intmi, int4mul, intdiv
  24.  *
  25.  * Arithmetic operators:
  26.  *  intmod, int4fac
  27.  *
  28.  * XXX makes massive and possibly unwarranted type promotion assumptions.
  29.  * fix me when we figure out what we want to do about ANSIfication...
  30.  */
  32. #include "postgres.h"
  33. #ifdef HAVE_LIMITS_H
  34. #include <limits.h>
  35. #endif
  37. #include "utils/builtins.h"
  39. #ifndef SHRT_MAX
  40. #define SHRT_MAX (0x7FFF)
  41. #endif
  42. #ifndef SHRT_MIN
  43. #define SHRT_MIN (-0x8000)
  44. #endif
  46. /*****************************************************************************
  47.  *  USER I/O ROUTINES  *
  48.  *****************************************************************************/
  50. /*
  51.  * int2in - converts "num" to short
  52.  */
  53. int32
  54. int2in(char *num)
  55. {
  56. return (int32) pg_atoi(num, sizeof(int16), '');
  57. }
  59. /*
  60.  * int2out - converts short to "num"
  61.  */
  62. char *
  63. int2out(int16 sh)
  64. {
  65. char    *result;
  67. result = (char *) palloc(7);/* assumes sign, 5 digits, '' */
  68. itoa((int) sh, result);
  69. return result;
  70. }
  72. /*
  73.  * int28in - converts "num num ..." to internal form
  74.  *
  75.  * Note:
  76.  * Fills any nonexistent digits with NULLs.
  77.  */
  78. int16 *
  79. int28in(char *shs)
  80. {
  81. int16    *result;
  82. int nums;
  84. if (shs == NULL)
  85. return NULL;
  87. result = (int16 *) palloc(sizeof(int16[8]));
  88. if ((nums = sscanf(shs, "%hd%hd%hd%hd%hd%hd%hd%hd",
  89.    &result[0],
  90.    &result[1],
  91.    &result[2],
  92.    &result[3],
  93.    &result[4],
  94.    &result[5],
  95.    &result[6],
  96.    &result[7])) != 8)
  97. {
  98. do
  99. result[nums++] = 0;
  100. while (nums < 8);
  101. }
  102. return result;
  103. }
  105. /*
  106.  * int28out - converts internal form to "num num ..."
  107.  */
  108. char *
  109. int28out(int16 *shs)
  110. {
  111. int num;
  112. int16    *sp;
  113. char    *rp;
  114. char    *result;
  116. if (shs == NULL)
  117. {
  118. result = (char *) palloc(2);
  119. result[0] = '-';
  120. result[1] = '';
  121. return result;
  122. }
  123. rp = result = (char *) palloc(8 * 7); /* assumes sign, 5 digits,
  124.  * ' ' */
  125. sp = shs;
  126. for (num = 8; num != 0; num--)
  127. {
  128. itoa(*sp++, rp);
  129. while (*++rp != '')
  130. ;
  131. *rp++ = ' ';
  132. }
  133. *--rp = '';
  134. return result;
  135. }
  137. /*
  138.  * int44in - converts "num num ..." to internal form
  139.  *
  140.  * Note:
  141.  * Fills any nonexistent digits with NULLs.
  142.  */
  143. int32 *
  144. int44in(char *input_string)
  145. {
  146. int32    *foo = (int32 *) palloc(4 * sizeof(int32));
  147. int i = 0;
  149. i = sscanf(input_string,
  150.    "%d, %d, %d, %d",
  151.    &foo[0],
  152.    &foo[1],
  153.    &foo[2],
  154.    &foo[3]);
  155. while (i < 4)
  156. foo[i++] = 0;
  158. return foo;
  159. }
  161. /*
  162.  * int28out - converts internal form to "num num ..."
  163.  */
  164. char *
  165. int44out(int32 *an_array)
  166. {
  167. int temp = 4;
  168. char    *output_string = NULL;
  169. int i;
  171. if (temp > 0)
  172. {
  173. char    *walk;
  175. output_string = (char *) palloc(16 * temp); /* assume 15 digits +
  176.  * sign */
  177. walk = output_string;
  178. for (i = 0; i < temp; i++)
  179. {
  180. itoa(an_array[i], walk);
  181. while (*++walk != '')
  182. ;
  183. *walk++ = ' ';
  184. }
  185. *--walk = '';
  186. }
  187. return output_string;
  188. }
  191. /*****************************************************************************
  192.  *  PUBLIC ROUTINES  *
  193.  *****************************************************************************/
  195. /*
  196.  * int4in - converts "num" to int4
  197.  */
  198. int32
  199. int4in(char *num)
  200. {
  201. return pg_atoi(num, sizeof(int32), '');
  202. }
  204. /*
  205.  * int4out - converts int4 to "num"
  206.  */
  207. char *
  208. int4out(int32 l)
  209. {
  210. char    *result;
  212. result = (char *) palloc(12); /* assumes sign, 10 digits, '' */
  213. ltoa(l, result);
  214. return result;
  215. }
  218. /*
  219.  * ===================
  220.  * CONVERSION ROUTINES
  221.  * ===================
  222.  */
  224. int32
  225. i2toi4(int16 arg1)
  226. {
  227. return (int32) arg1;
  228. }
  230. int16
  231. i4toi2(int32 arg1)
  232. {
  233. if (arg1 < SHRT_MIN)
  234. elog(ERROR, "i4toi2: '%d' causes int2 underflow", arg1);
  235. if (arg1 > SHRT_MAX)
  236. elog(ERROR, "i4toi2: '%d' causes int2 overflow", arg1);
  238. return (int16) arg1;
  239. }
  241. text *
  242. int2_text(int16 arg1)
  243. {
  244. text    *result;
  246. int len;
  247. char    *str;
  249. str = int2out(arg1);
  250. len = (strlen(str) + VARHDRSZ);
  252. result = palloc(len);
  254. VARSIZE(result) = len;
  255. memmove(VARDATA(result), str, (len - VARHDRSZ));
  257. pfree(str);
  259. return result;
  260. } /* int2_text() */
  262. int16
  263. text_int2(text *string)
  264. {
  265. int16 result;
  267. int len;
  268. char    *str;
  270. len = (VARSIZE(string) - VARHDRSZ);
  272. str = palloc(len + 1);
  273. memmove(str, VARDATA(string), len);
  274. *(str + len) = '';
  276. result = int2in(str);
  277. pfree(str);
  279. return result;
  280. } /* text_int2() */
  282. text *
  283. int4_text(int32 arg1)
  284. {
  285. text    *result;
  287. int len;
  288. char    *str;
  290. str = int4out(arg1);
  291. len = (strlen(str) + VARHDRSZ);
  293. result = palloc(len);
  295. VARSIZE(result) = len;
  296. memmove(VARDATA(result), str, (len - VARHDRSZ));
  298. pfree(str);
  300. return result;
  301. } /* int4_text() */
  303. int32
  304. text_int4(text *string)
  305. {
  306. int32 result;
  308. int len;
  309. char    *str;
  311. len = (VARSIZE(string) - VARHDRSZ);
  313. str = palloc(len + 1);
  314. memmove(str, VARDATA(string), len);
  315. *(str + len) = '';
  317. result = int4in(str);
  318. pfree(str);
  320. return result;
  321. } /* text_int4() */
  324. /*
  325.  * =========================
  326.  * BOOLEAN OPERATOR ROUTINES
  327.  * =========================
  328.  */
  330. /*
  331.  * inteq - returns 1 iff arg1 == arg2
  332.  * intne - returns 1 iff arg1 != arg2
  333.  * intlt - returns 1 iff arg1 < arg2
  334.  * intle - returns 1 iff arg1 <= arg2
  335.  * intgt - returns 1 iff arg1 > arg2
  336.  * intge - returns 1 iff arg1 >= arg2
  337.  */
  338. bool
  339. int4eq(int32 arg1, int32 arg2)
  340. {
  341. return arg1 == arg2;
  342. }
  344. bool
  345. int4ne(int32 arg1, int32 arg2)
  346. {
  347. return arg1 != arg2;
  348. }
  350. bool
  351. int4lt(int32 arg1, int32 arg2)
  352. {
  353. return arg1 < arg2;
  354. }
  356. bool
  357. int4le(int32 arg1, int32 arg2)
  358. {
  359. return arg1 <= arg2;
  360. }
  362. bool
  363. int4gt(int32 arg1, int32 arg2)
  364. {
  365. return arg1 > arg2;
  366. }
  368. bool
  369. int4ge(int32 arg1, int32 arg2)
  370. {
  371. return arg1 >= arg2;
  372. }
  374. bool
  375. int2eq(int16 arg1, int16 arg2)
  376. {
  377. return arg1 == arg2;
  378. }
  380. bool
  381. int2ne(int16 arg1, int16 arg2)
  382. {
  383. return arg1 != arg2;
  384. }
  386. bool
  387. int2lt(int16 arg1, int16 arg2)
  388. {
  389. return arg1 < arg2;
  390. }
  392. bool
  393. int2le(int16 arg1, int16 arg2)
  394. {
  395. return arg1 <= arg2;
  396. }
  398. bool
  399. int2gt(int16 arg1, int16 arg2)
  400. {
  401. return arg1 > arg2;
  402. }
  404. bool
  405. int2ge(int16 arg1, int16 arg2)
  406. {
  407. return arg1 >= arg2;
  408. }
  410. bool
  411. int24eq(int32 arg1, int32 arg2)
  412. {
  413. return arg1 == arg2;
  414. }
  416. bool
  417. int24ne(int32 arg1, int32 arg2)
  418. {
  419. return arg1 != arg2;
  420. }
  422. bool
  423. int24lt(int32 arg1, int32 arg2)
  424. {
  425. return arg1 < arg2;
  426. }
  428. bool
  429. int24le(int32 arg1, int32 arg2)
  430. {
  431. return arg1 <= arg2;
  432. }
  434. bool
  435. int24gt(int32 arg1, int32 arg2)
  436. {
  437. return arg1 > arg2;
  438. }
  440. bool
  441. int24ge(int32 arg1, int32 arg2)
  442. {
  443. return arg1 >= arg2;
  444. }
  446. bool
  447. int42eq(int32 arg1, int32 arg2)
  448. {
  449. return arg1 == arg2;
  450. }
  452. bool
  453. int42ne(int32 arg1, int32 arg2)
  454. {
  455. return arg1 != arg2;
  456. }
  458. bool
  459. int42lt(int32 arg1, int32 arg2)
  460. {
  461. return arg1 < arg2;
  462. }
  464. bool
  465. int42le(int32 arg1, int32 arg2)
  466. {
  467. return arg1 <= arg2;
  468. }
  470. bool
  471. int42gt(int32 arg1, int32 arg2)
  472. {
  473. return arg1 > arg2;
  474. }
  476. bool
  477. int42ge(int32 arg1, int32 arg2)
  478. {
  479. return arg1 >= arg2;
  480. }
  483. bool
  484. keyfirsteq(int16 *arg1, int16 arg2)
  485. {
  486. return *arg1 == arg2;
  487. }
  489. /*
  490.  * int[24]pl - returns arg1 + arg2
  491.  * int[24]mi - returns arg1 - arg2
  492.  * int[24]mul - returns arg1 * arg2
  493.  * int[24]div - returns arg1 / arg2
  494.  */
  495. int32
  496. int4um(int32 arg)
  497. {
  498. return -arg;
  499. }
  501. int32
  502. int4pl(int32 arg1, int32 arg2)
  503. {
  504. return arg1 + arg2;
  505. }
  507. int32
  508. int4mi(int32 arg1, int32 arg2)
  509. {
  510. return arg1 - arg2;
  511. }
  513. int32
  514. int4mul(int32 arg1, int32 arg2)
  515. {
  516. return arg1 * arg2;
  517. }
  519. int32
  520. int4div(int32 arg1, int32 arg2)
  521. {
  522. return arg1 / arg2;
  523. }
  525. int32
  526. int4inc(int32 arg)
  527. {
  528. return arg + (int32) 1;
  529. }
  531. int16
  532. int2um(int16 arg)
  533. {
  534. return -arg;
  535. }
  537. int16
  538. int2pl(int16 arg1, int16 arg2)
  539. {
  540. return arg1 + arg2;
  541. }
  543. int16
  544. int2mi(int16 arg1, int16 arg2)
  545. {
  546. return arg1 - arg2;
  547. }
  549. int16
  550. int2mul(int16 arg1, int16 arg2)
  551. {
  552. return arg1 * arg2;
  553. }
  555. int16
  556. int2div(int16 arg1, int16 arg2)
  557. {
  558. return arg1 / arg2;
  559. }
  561. int16
  562. int2inc(int16 arg)
  563. {
  564. return arg + (int16) 1;
  565. }
  567. int32
  568. int24pl(int32 arg1, int32 arg2)
  569. {
  570. return arg1 + arg2;
  571. }
  573. int32
  574. int24mi(int32 arg1, int32 arg2)
  575. {
  576. return arg1 - arg2;
  577. }
  579. int32
  580. int24mul(int32 arg1, int32 arg2)
  581. {
  582. return arg1 * arg2;
  583. }
  585. int32
  586. int24div(int32 arg1, int32 arg2)
  587. {
  588. return arg1 / arg2;
  589. }
  591. int32
  592. int42pl(int32 arg1, int32 arg2)
  593. {
  594. return arg1 + arg2;
  595. }
  597. int32
  598. int42mi(int32 arg1, int32 arg2)
  599. {
  600. return arg1 - arg2;
  601. }
  603. int32
  604. int42mul(int32 arg1, int32 arg2)
  605. {
  606. return arg1 * arg2;
  607. }
  609. int32
  610. int42div(int32 arg1, int32 arg2)
  611. {
  612. return arg1 / arg2;
  613. }
  615. /*
  616.  * int[24]mod - returns arg1 mod arg2
  617.  */
  618. int32
  619. int4mod(int32 arg1, int32 arg2)
  620. {
  621. return arg1 % arg2;
  622. }
  624. int32
  625. int2mod(int16 arg1, int16 arg2)
  626. {
  627. return arg1 % arg2;
  628. }
  630. int32
  631. int24mod(int32 arg1, int32 arg2)
  632. {
  633. return arg1 % arg2;
  634. }
  636. int32
  637. int42mod(int32 arg1, int32 arg2)
  638. {
  639. return arg1 % arg2;
  640. }
  642. /*
  643.  * int[24]fac - returns arg1!
  644.  */
  645. int32
  646. int4fac(int32 arg1)
  647. {
  648. int32 result;
  650. if (arg1 < 1)
  651. result = 0;
  652. else
  653. for (result = 1; arg1 > 0; --arg1)
  654. result *= arg1;
  655. return result;
  656. }
  658. int32
  659. int2fac(int16 arg1)
  660. {
  661. int16 result;
  663. if (arg1 < 1)
  664. result = 0;
  665. else
  666. for (result = 1; arg1 > 0; --arg1)
  667. result *= arg1;
  668. return result;
  669. }
  671. int16
  672. int2larger(int16 arg1, int16 arg2)
  673. {
  674. return (arg1 > arg2) ? arg1 : arg2;
  675. }
  677. int16
  678. int2smaller(int16 arg1, int16 arg2)
  679. {
  680. return (arg1 < arg2) ? arg1 : arg2;
  681. }
  683. int32
  684. int4larger(int32 arg1, int32 arg2)
  685. {
  686. return (arg1 > arg2) ? arg1 : arg2;
  687. }
  689. int32
  690. int4smaller(int32 arg1, int32 arg2)
  691. {
  692. return (arg1 < arg2) ? arg1 : arg2;
  693. }