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

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

数据库系统

开发平台：

Unix_Linux

snprintf.c：源码内容
  1. /*
  2.  * Copyright (c) 1983, 1995, 1996 Eric P. Allman
  3.  * Copyright (c) 1988, 1993
  4.  * The Regents of the University of California.  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
  8.  * are met:
  9.  * 1. Redistributions of source code must retain the above copyright
  10.  *   notice, this list of conditions and the following disclaimer.
  11.  * 2. 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.  * 3. All advertising materials mentioning features or use of this software
  15.  *   must display the following acknowledgement:
  16.  * This product includes software developed by the University of
  17.  * California, Berkeley and its contributors.
  18.  * 4. Neither the name of the University nor the names of its contributors
  19.  *   may be used to endorse or promote products derived from this software
  20.  *   without specific prior written permission.
  21.  *
  22.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  23.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  24.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  25.  * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  26.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  27.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  28.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  29.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  30.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  31.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32.  * SUCH DAMAGE.
  33.  */
  34. #ifdef NOT_USED
  35. #include "sendmail.h"
  36. #include "pathnames.h"
  37. #endif
  39. #include "postgres.h"
  41. #include "regex/cdefs.h"
  43. #include <stdio.h>
  44. #include <stdarg.h>
  46. #include <sys/ioctl.h>
  47. #include <sys/param.h>
  49. /*
  50.  * We do all internal arithmetic in the widest available integer type,
  51.  * here called long_long (or ulong_long for unsigned).
  52.  */
  53. #ifdef HAVE_LONG_LONG_INT_64
  54. typedef long long long_long;
  55. typedef unsigned long long ulong_long;
  57. #else
  58. typedef long long_long;
  59. typedef unsigned long ulong_long;
  61. #endif
  63. /*
  64. ** SNPRINTF, VSNPRINT -- counted versions of printf
  65. **
  66. ** These versions have been grabbed off the net.  They have been
  67. ** cleaned up to compile properly and support for .precision and
  68. ** %lx has been added.
  69. */
  71. /**************************************************************
  72.  * Original:
  73.  * Patrick Powell Tue Apr 11 09:48:21 PDT 1995
  74.  * A bombproof version of doprnt (dopr) included.
  75.  * Sigh.  This sort of thing is always nasty do deal with. Note that
  76.  * the version here does not include floating point. (now it does ... tgl)
  77.  *
  78.  * snprintf() is used instead of sprintf() as it does limit checks
  79.  * for string length.  This covers a nasty loophole.
  80.  *
  81.  * The other functions are there to prevent NULL pointers from
  82.  * causing nast effects.
  83.  **************************************************************/
  85. /*static char _id[] = "$Id: snprintf.c,v 1.22 1999/05/25 16:10:28 momjian Exp $";*/
  86. static char *end;
  87. static int SnprfOverflow;
  89. int snprintf(char *str, size_t count, const char *fmt,...);
  90. int vsnprintf(char *str, size_t count, const char *fmt, va_list args);
  91. static void dopr(char *buffer, const char *format, va_list args);
  93. int
  94. snprintf(char *str, size_t count, const char *fmt,...)
  95. {
  96. int len;
  97. va_list args;
  99. va_start(args, fmt);
  100. len = vsnprintf(str, count, fmt, args);
  101. va_end(args);
  102. return len;
  103. }
  106. int
  107. vsnprintf(char *str, size_t count, const char *fmt, va_list args)
  108. {
  109. str[0] = 0;
  110. end = str + count - 1;
  111. SnprfOverflow = 0;
  112. dopr(str, fmt, args);
  113. if (count > 0)
  114. end[0] = 0;
  115. if (SnprfOverflow)
  116. elog(NOTICE, "vsnprintf overflow, len = %d, str = %s",
  117.  count, str);
  118. return strlen(str);
  119. }
  121. /*
  122.  * dopr(): poor man's version of doprintf
  123.  */
  125. static void fmtstr(char *value, int ljust, int len, int zpad, int maxwidth);
  126. static void fmtnum(long_long value, int base, int dosign, int ljust, int len, int zpad);
  127. static void fmtfloat(double value, char type, int ljust, int len, int precision, int pointflag);
  128. static void dostr(char *str, int cut);
  129. static void dopr_outch(int c);
  131. static char *output;
  134. static void
  135. dopr(char *buffer, const char *format, va_list args)
  136. {
  137. int ch;
  138. long_long value;
  139. double fvalue;
  140. int longlongflag = 0;
  141. int longflag = 0;
  142. int pointflag = 0;
  143. int maxwidth = 0;
  144. char    *strvalue;
  145. int ljust;
  146. int len;
  147. int zpad;
  149. output = buffer;
  150. while ((ch = *format++))
  151. {
  152. switch (ch)
  153. {
  154. case '%':
  155. ljust = len = zpad = maxwidth = 0;
  156. longflag = longlongflag = pointflag = 0;
  157. nextch:
  158. ch = *format++;
  159. switch (ch)
  160. {
  161. case 0:
  162. dostr("**end of format**", 0);
  163. return;
  164. case '-':
  165. ljust = 1;
  166. goto nextch;
  167. case '0': /* set zero padding if len not set */
  168. if (len == 0 && !pointflag)
  169. zpad = '0';
  170. case '1':
  171. case '2':
  172. case '3':
  173. case '4':
  174. case '5':
  175. case '6':
  176. case '7':
  177. case '8':
  178. case '9':
  179. if (pointflag)
  180. maxwidth = maxwidth * 10 + ch - '0';
  181. else
  182. len = len * 10 + ch - '0';
  183. goto nextch;
  184. case '*':
  185. if (pointflag)
  186. maxwidth = va_arg(args, int);
  187. else
  188. len = va_arg(args, int);
  189. goto nextch;
  190. case '.':
  191. pointflag = 1;
  192. goto nextch;
  193. case 'l':
  194. if (longflag)
  195. longlongflag = 1;
  196. else
  197. longflag = 1;
  198. goto nextch;
  199. case 'u':
  200. case 'U':
  201. /* fmtnum(value,base,dosign,ljust,len,zpad) */
  202. if (longflag)
  203. {
  204. if (longlongflag)
  205. value = va_arg(args, long_long);
  206. else
  207. value = va_arg(args, long);
  208. }
  209. else
  210. value = va_arg(args, int);
  211. fmtnum(value, 10, 0, ljust, len, zpad);
  212. break;
  213. case 'o':
  214. case 'O':
  215. /* fmtnum(value,base,dosign,ljust,len,zpad) */
  216. if (longflag)
  217. {
  218. if (longlongflag)
  219. value = va_arg(args, long_long);
  220. else
  221. value = va_arg(args, long);
  222. }
  223. else
  224. value = va_arg(args, int);
  225. fmtnum(value, 8, 0, ljust, len, zpad);
  226. break;
  227. case 'd':
  228. case 'D':
  229. if (longflag)
  230. {
  231. if (longlongflag)
  232. value = va_arg(args, long_long);
  233. else
  234. value = va_arg(args, long);
  235. }
  236. else
  237. value = va_arg(args, int);
  239. fmtnum(value, 10, 1, ljust, len, zpad);
  240. break;
  241. case 'x':
  242. if (longflag)
  243. {
  244. if (longlongflag)
  245. value = va_arg(args, long_long);
  246. else
  247. value = va_arg(args, long);
  248. }
  249. else
  250. value = va_arg(args, int);
  251. fmtnum(value, 16, 0, ljust, len, zpad);
  252. break;
  253. case 'X':
  254. if (longflag)
  255. {
  256. if (longlongflag)
  257. value = va_arg(args, long_long);
  258. else
  259. value = va_arg(args, long);
  260. }
  261. else
  262. value = va_arg(args, int);
  263. fmtnum(value, -16, 0, ljust, len, zpad);
  264. break;
  265. case 's':
  266. strvalue = va_arg(args, char *);
  267. if (maxwidth > 0 || !pointflag)
  268. {
  269. if (pointflag && len > maxwidth)
  270. len = maxwidth; /* Adjust padding */
  271. fmtstr(strvalue, ljust, len, zpad, maxwidth);
  272. }
  273. break;
  274. case 'c':
  275. ch = va_arg(args, int);
  276. dopr_outch(ch);
  277. break;
  278. case 'e':
  279. case 'E':
  280. case 'f':
  281. case 'g':
  282. case 'G':
  283. fvalue = va_arg(args, double);
  284. fmtfloat(fvalue, ch, ljust, len, maxwidth, pointflag);
  285. break;
  286. case '%':
  287. dopr_outch(ch);
  288. continue;
  289. default:
  290. dostr("???????", 0);
  291. }
  292. break;
  293. default:
  294. dopr_outch(ch);
  295. break;
  296. }
  297. }
  298. *output = 0;
  299. }
  301. static void
  302. fmtstr(char *value, int ljust, int len, int zpad, int maxwidth)
  303. {
  304. int padlen,
  305. strlen; /* amount to pad */
  307. if (value == 0)
  308. value = "<NULL>";
  309. for (strlen = 0; value[strlen]; ++strlen); /* strlen */
  310. if (strlen > maxwidth && maxwidth)
  311. strlen = maxwidth;
  312. padlen = len - strlen;
  313. if (padlen < 0)
  314. padlen = 0;
  315. if (ljust)
  316. padlen = -padlen;
  317. while (padlen > 0)
  318. {
  319. dopr_outch(' ');
  320. --padlen;
  321. }
  322. dostr(value, maxwidth);
  323. while (padlen < 0)
  324. {
  325. dopr_outch(' ');
  326. ++padlen;
  327. }
  328. }
  330. static void
  331. fmtnum(long_long value, int base, int dosign, int ljust, int len, int zpad)
  332. {
  333. int signvalue = 0;
  334. ulong_long uvalue;
  335. char convert[64];
  336. int place = 0;
  337. int padlen = 0; /* amount to pad */
  338. int caps = 0;
  340. /*
  341.  * DEBUGP(("value 0x%x, base %d, dosign %d, ljust %d, len %d, zpad
  342.  * %dn", value, base, dosign, ljust, len, zpad ));
  343.  */
  344. uvalue = value;
  345. if (dosign)
  346. {
  347. if (value < 0)
  348. {
  349. signvalue = '-';
  350. uvalue = -value;
  351. }
  352. }
  353. if (base < 0)
  354. {
  355. caps = 1;
  356. base = -base;
  357. }
  358. do
  359. {
  360. convert[place++] = (caps ? "0123456789ABCDEF" : "0123456789abcdef")
  361. [uvalue % (unsigned) base];
  362. uvalue = (uvalue / (unsigned) base);
  363. } while (uvalue);
  364. convert[place] = 0;
  366. if (len < 0)
  367. {
  368. /* this could happen with a "*" width spec */
  369. ljust = 1;
  370. len = -len;
  371. }
  372. padlen = len - place;
  373. if (padlen < 0)
  374. padlen = 0;
  375. if (ljust)
  376. padlen = -padlen;
  378. /*
  379.  * DEBUGP(( "str '%s', place %d, sign %c, padlen %dn",
  380.  * convert,place,signvalue,padlen));
  381.  */
  382. if (zpad && padlen > 0)
  383. {
  384. if (signvalue)
  385. {
  386. dopr_outch(signvalue);
  387. --padlen;
  388. signvalue = 0;
  389. }
  390. while (padlen > 0)
  391. {
  392. dopr_outch(zpad);
  393. --padlen;
  394. }
  395. }
  396. while (padlen > 0)
  397. {
  398. dopr_outch(' ');
  399. --padlen;
  400. }
  401. if (signvalue)
  402. dopr_outch(signvalue);
  403. while (place > 0)
  404. dopr_outch(convert[--place]);
  405. while (padlen < 0)
  406. {
  407. dopr_outch(' ');
  408. ++padlen;
  409. }
  410. }
  412. static void
  413. fmtfloat(double value, char type, int ljust, int len, int precision, int pointflag)
  414. {
  415. char fmt[32];
  416. char convert[512];
  417. int padlen = 0; /* amount to pad */
  419. /* we rely on regular C library's sprintf to do the basic conversion */
  420. if (pointflag)
  421. sprintf(fmt, "%%.%d%c", precision, type);
  422. else
  423. sprintf(fmt, "%%%c", type);
  424. sprintf(convert, fmt, value);
  426. if (len < 0)
  427. {
  428. /* this could happen with a "*" width spec */
  429. ljust = 1;
  430. len = -len;
  431. }
  432. padlen = len - strlen(convert);
  433. if (padlen < 0)
  434. padlen = 0;
  435. if (ljust)
  436. padlen = -padlen;
  438. while (padlen > 0)
  439. {
  440. dopr_outch(' ');
  441. --padlen;
  442. }
  443. dostr(convert, 0);
  444. while (padlen < 0)
  445. {
  446. dopr_outch(' ');
  447. ++padlen;
  448. }
  449. }
  451. static void
  452. dostr(char *str, int cut)
  453. {
  454. if (cut)
  455. {
  456. while (*str && cut-- > 0)
  457. dopr_outch(*str++);
  458. }
  459. else
  460. {
  461. while (*str)
  462. dopr_outch(*str++);
  463. }
  464. }
  466. static void
  467. dopr_outch(int c)
  468. {
  469. #ifdef NOT_USED
  470. if (iscntrl(c) && c != 'n' && c != 't')
  471. {
  472. c = '@' + (c & 0x1F);
  473. if (end == 0 || output < end)
  474. *output++ = '^';
  475. }
  476. #endif
  477. if (end == 0 || output < end)
  478. *output++ = c;
  479. else
  480. SnprfOverflow++;
  481. }