home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cbase.zip / CBASE10B.ZIP / CBASE.ZIP / CBEXP.C < prev    next >
Text File  |  1989-11-08  |  8KB  |  418 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "cbexp.c    1.2 - 89/11/08" */
  5.  
  6. #include <ctype.h>
  7. #include <errno.h>
  8. #include <limits.h>
  9. #include <stdio.h>
  10. /*#include <stddef.h>*/
  11. /*#include <string.h>*/
  12. #include "cbase_.h"
  13.  
  14. /*man---------------------------------------------------------------------------
  15. NAME
  16.      cbexp - cbase export functions
  17.  
  18. SYNOPSIS
  19.  
  20. DESCRIPTION
  21.  
  22. SEE ALSO
  23.      cbcmp, cbimp.
  24.  
  25. DIAGNOSTICS
  26.  
  27. WARNINGS
  28.      Pointer format is implementation defined; it could possibly
  29.      contain the field delimiter ('|') or escape ('\\\\') chars.  If
  30.      so, the field delimiter or escape character will have to be
  31.      changed.
  32.  
  33. ------------------------------------------------------------------------------*/
  34. /* array data type export macro */
  35. #define vexp(FP, P, N, TYPE, EXPFCT) {                    \
  36.     int i = 0;                            \
  37.     TYPE *cp = (TYPE *)(P);                        \
  38.                                     \
  39.     for (i = 0; ; i++) {                        \
  40.         if ((EXPFCT)((FP), cp, (N)) == -1) return -1;        \
  41.         if (i >= ((N) / sizeof(*cp) - 1)) break;        \
  42.         if (fputc(EXPFLDDLM, (FP)) == EOF) return -1;        \
  43.         cp++;                            \
  44.     }                                \
  45. }
  46.  
  47. #define charexp        (ucharexp)
  48.  
  49. #define charvexp    (ucharvexp)
  50.  
  51. static int ucharexp(fp, p, n)
  52. FILE *fp;
  53. CONST void *p;
  54. size_t n;
  55. {
  56.     unsigned char c = *(unsigned char *)p;
  57.  
  58.     switch (c) {
  59.     case EXPFLDDLM:    /* export file field delimiter */
  60.         if (fputc(EXPESC, fp) == EOF) return -1;
  61.         if (fputc('F', fp) == EOF) return -1;
  62.         break;    /* case EXPFLDDLM: */
  63.     case EXPESC:    /* export file field escape character */
  64.         if (fputc(EXPESC, fp) == EOF) return -1;
  65.         if (fputc(EXPESC, fp) == EOF) return -1;
  66.         break;    /* case EXPESC: */
  67. #if __STDC__ == 1
  68.     case '\a':    /* audible alert */
  69.         if (fputc(EXPESC, fp) == EOF) return -1;
  70.         if (fputc('a', fp) == EOF) return -1;
  71.         break;    /* case '\a': */
  72. #endif
  73.     case '\b':    /* backspace */
  74.         if (fputc(EXPESC, fp) == EOF) return -1;
  75.         if (fputc('b', fp) == EOF) return -1;
  76.         break;    /* case '\b': */
  77.     case '\f':    /* form feed */
  78.         if (fputc(EXPESC, fp) == EOF) return -1;
  79.         if (fputc('f', fp) == EOF) return -1;
  80.         break;    /* case '\f': */
  81.     case '\n':    /* newline */
  82.         if (fputc(EXPESC, fp) == EOF) return -1;
  83.         if (fputc('n', fp) == EOF) return -1;
  84.         break;    /* case '\n': */
  85.     case '\r':    /* carriage return */
  86.         if (fputc(EXPESC, fp) == EOF) return -1;
  87.         if (fputc('r', fp) == EOF) return -1;
  88.         break;    /* case '\r': */
  89.     case '\t':    /* horizontal tab */
  90.         if (fputc(EXPESC, fp) == EOF) return -1;
  91.         if (fputc('t', fp) == EOF) return -1;
  92.         break;    /* case '\t': */
  93.     case '\v':    /* vertical tab */
  94.         if (fputc(EXPESC, fp) == EOF) return -1;
  95.         if (fputc('v', fp) == EOF) return -1;
  96.         break;    /* case '\v': */
  97.     default:
  98.         if (isprint(c)) {
  99.             if (fputc(c, fp) == EOF) return -1;
  100.         } else {
  101.             if (fprintf(fp, "%c%.3o", (int)EXPESC, (int)c) < 0) {
  102.                 return -1;
  103.             }
  104.         }
  105.     }
  106.  
  107.     return 0;
  108. }
  109.  
  110. static int ucharvexp(fp, p, n)
  111. FILE *fp;
  112. CONST void *p;
  113. size_t n;
  114. {
  115.     vexp(fp, p, n, unsigned char, ucharexp);
  116.  
  117.     return 0;
  118. }
  119.  
  120. static int shortexp(fp, p, n)
  121. FILE *fp;
  122. CONST void *p;
  123. size_t n;
  124. {
  125.     SIGNED short x = 0;
  126.  
  127.     memcpy(&x, p, sizeof(x));
  128.     if (fprintf(fp, "%hd", (int)x) < 0) return -1;
  129.  
  130.     return 0;
  131. }
  132.  
  133. static int shortvexp(fp, p, n)
  134. FILE *fp;
  135. CONST void *p;
  136. size_t n;
  137. {
  138.     vexp(fp, p, n, SIGNED short, shortexp);
  139.  
  140.     return 0;
  141. }
  142.  
  143. static int ushortexp(fp, p, n)
  144. FILE *fp;
  145. CONST void *p;
  146. size_t n;
  147. {
  148.     unsigned short x = 0;
  149.  
  150.     memcpy(&x, p, sizeof(x));
  151.     if (fprintf(fp, "%hu", (unsigned int)x) < 0) return -1;
  152.  
  153.     return 0;
  154. }
  155.  
  156. static int ushortvexp(fp, p, n)
  157. FILE *fp;
  158. CONST void *p;
  159. size_t n;
  160. {
  161.     vexp(fp, p, n, unsigned short, ushortexp);
  162.  
  163.     return 0;
  164. }
  165.  
  166. static int intexp(fp, p, n)
  167. FILE *fp;
  168. CONST void *p;
  169. size_t n;
  170. {
  171.     SIGNED int x = 0;
  172.  
  173.     memcpy(&x, p, sizeof(x));
  174.     if (fprintf(fp, "%d", x) < 0) return -1;
  175.  
  176.     return 0;
  177. }
  178.  
  179. static int intvexp(fp, p, n)
  180. FILE *fp;
  181. CONST void *p;
  182. size_t n;
  183. {
  184.     vexp(fp, p, n, SIGNED int, intexp);
  185.  
  186.     return 0;
  187. }
  188.  
  189. static int uintexp(fp, p, n)
  190. FILE *fp;
  191. CONST void *p;
  192. size_t n;
  193. {
  194.     unsigned int x = 0;
  195.  
  196.     memcpy(&x, p, sizeof(x));
  197.     if (fprintf(fp, "%u", x) < 0) return -1;
  198.  
  199.     return 0;
  200. }
  201.  
  202. static int uintvexp(fp, p, n)
  203. FILE *fp;
  204. CONST void *p;
  205. size_t n;
  206. {
  207.     vexp(fp, p, n, unsigned int, uintexp);
  208.  
  209.     return 0;
  210. }
  211.  
  212. static int longexp(fp, p, n)
  213. FILE *fp;
  214. CONST void *p;
  215. size_t n;
  216. {
  217.     SIGNED long x = 0;
  218.  
  219.     memcpy(&x, p, sizeof(x));
  220.     if (fprintf(fp, "%ld", x) < 0) return -1;
  221.  
  222.     return 0;
  223. }
  224.  
  225. static int longvexp(fp, p, n)
  226. FILE *fp;
  227. CONST void *p;
  228. size_t n;
  229. {
  230.     vexp(fp, p, n, SIGNED long, longexp);
  231.  
  232.     return 0;
  233. }
  234.  
  235. static int ulongexp(fp, p, n)
  236. FILE *fp;
  237. CONST void *p;
  238. size_t n;
  239. {
  240.     unsigned long x = 0;
  241.  
  242.     memcpy(&x, p, sizeof(x));
  243.     if (fprintf(fp, "%lu", x) < 0) return -1;
  244.  
  245.     return 0;
  246. }
  247.  
  248. static int ulongvexp(fp, p, n)
  249. FILE *fp;
  250. CONST void *p;
  251. size_t n;
  252. {
  253.     vexp(fp, p, n, unsigned long, ulongexp);
  254.  
  255.     return 0;
  256. }
  257.  
  258. static int floatexp(fp, p, n)
  259. FILE *fp;
  260. CONST void *p;
  261. size_t n;
  262. {
  263.     float x = 0;
  264.  
  265.     memcpy(&x, p, sizeof(x));
  266.     if (fprintf(fp, "%G", (double)x) < 0) return -1;
  267.  
  268.     return 0;
  269. }
  270.  
  271. static int floatvexp(fp, p, n)
  272. FILE *fp;
  273. CONST void *p;
  274. size_t n;
  275. {
  276.     vexp(fp, p, n, float, floatexp);
  277.  
  278.     return 0;
  279. }
  280.  
  281. static int doubleexp(fp, p, n)
  282. FILE *fp;
  283. CONST void *p;
  284. size_t n;
  285. {
  286.     double x = 0;
  287.  
  288.     memcpy(&x, p, sizeof(x));
  289.     if (fprintf(fp, "%G", x) < 0) return -1;
  290.  
  291.     return 0;
  292. }
  293.  
  294. static int doublevexp(fp, p, n)
  295. FILE *fp;
  296. CONST void *p;
  297. size_t n;
  298. {
  299.     vexp(fp, p, n, double, doubleexp);
  300.  
  301.     return 0;
  302. }
  303.  
  304. static int ldoubleexp(fp, p, n)
  305. FILE *fp;
  306. CONST void *p;
  307. size_t n;
  308. {
  309.     LDOUBLE x = 0;
  310.  
  311.     memcpy(&x, p, sizeof(x));
  312.     if (fprintf(fp, "%lG", x) < 0) return -1;
  313.  
  314.     return 0;
  315. }
  316.  
  317. static int ldoublevexp(fp, p, n)
  318. FILE *fp;
  319. CONST void *p;
  320. size_t n;
  321. {
  322.     vexp(fp, p, n, LDOUBLE, ldoubleexp);
  323.  
  324.     return 0;
  325. }
  326.  
  327. static int pointerexp(fp, p, n)
  328. FILE *fp;
  329. CONST void *p;
  330. size_t n;
  331. {
  332.     void *x = NULL;
  333.  
  334.     memcpy(&x, p, sizeof(x));
  335.     if (fprintf(fp, "%p", x) < 0) return -1;
  336.  
  337.     return 0;
  338. }
  339.  
  340. static int pointervexp(fp, p, n)
  341. FILE *fp;
  342. CONST void *p;
  343. size_t n;
  344. {
  345.     vexp(fp, p, n, void *, pointerexp);
  346.  
  347.     return 0;
  348. }
  349.  
  350. static int stringexp(fp, p, n)
  351. FILE *fp;
  352. CONST void *p;
  353. size_t n;
  354. {
  355.     char *s = (char *)p;
  356.     int i = 0;
  357.  
  358.     for (i = 0; i < n; i++) {
  359.         if (s[i] == '\0') {
  360.             break;
  361.         }
  362.         if (ucharexp(fp, &s[i], sizeof(*s)) == -1) {
  363.             return -1;
  364.         }
  365.     }
  366.  
  367.     return 0;
  368. }
  369.  
  370. static int binaryexp(fp, p, n)
  371. FILE *fp;
  372. CONST void *p;
  373. size_t n;
  374. {
  375.     /* calculate number of hex digits for each char
  376.          # bits in char == CHAR_BIT, # bits in hex digit == 4 */
  377.     CONST int hexdigits = (CHAR_BIT + (4 - 1)) / 4;
  378.     unsigned char *pi = (unsigned char *)p;
  379.     char fmt[24];            /* printf format string */
  380.  
  381.     sprintf(fmt, "%%.%dX", hexdigits);
  382.     while (pi < ((unsigned char *)p + n)) {
  383.         if (fprintf(fp, fmt, (unsigned int)*pi++) < 0) return -1;
  384.     }
  385.  
  386.     return 0;
  387. }
  388.  
  389. /* export function table definition */
  390. CONST cbexp_t cbexpv[] = {
  391.     charexp,    /* t_char    =  0 */
  392.     charvexp,    /* t_charv    =  1 */
  393.     ucharexp,    /* t_uchar    =  2 */
  394.     ucharvexp,    /* t_ucharv    =  3 */
  395.     shortexp,    /* t_short    =  4 */
  396.     shortvexp,    /* t_shortv    =  5 */
  397.     ushortexp,    /* t_ushort    =  6 */
  398.     ushortvexp,    /* t_ushortv    =  7 */
  399.     intexp,        /* t_int    =  8 */
  400.     intvexp,    /* t_intv    =  9 */
  401.     uintexp,    /* t_uint    = 10 */
  402.     uintvexp,    /* t_uintv    = 11 */
  403.     longexp,    /* t_long    = 12 */
  404.     longvexp,    /* t_longv    = 13 */
  405.     ulongexp,    /* t_ulong    = 14 */
  406.     ulongvexp,    /* t_ulongv    = 15 */
  407.     floatexp,    /* t_float    = 16 */
  408.     floatvexp,    /* t_floatv    = 17 */
  409.     doubleexp,    /* t_double    = 18 */
  410.     doublevexp,    /* t_doublev    = 19 */
  411.     ldoubleexp,    /* t_ldouble    = 20 */
  412.     ldoublevexp,    /* t_ldoublev    = 21 */
  413.     pointerexp,    /* t_pointer    = 22 */
  414.     pointervexp,    /* t_pointerv    = 23 */
  415.     stringexp,    /* t_string    = 24 */
  416.     binaryexp    /* t_binary    = 25 */
  417. };
  418.