home *** CD-ROM | disk | FTP | other *** search
/ Shareware Overload / ShartewareOverload.cdr / progm / cbase.zip / CBASE10B.ZIP / CBASE.ZIP / CBIMP.C < prev    next >
Text File  |  1989-11-08  |  9KB  |  507 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "cbimp.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. #ifndef isodigit
  15. #define isodigit(c)    (((c >= '0') && (c <= '7')) ? 1 : 0)
  16. #endif
  17.  
  18. /*man---------------------------------------------------------------------------
  19. NAME
  20.      cbimp - import cbase data
  21.  
  22. SYNOPSIS
  23.  
  24. DESCRIPTION
  25.  
  26. SEE ALSO
  27.      cbcmp, cbexp.
  28.  
  29. DIAGNOSTICS
  30.      Upon successful completion, a value of 0 is returned.  Otherwise,
  31.      a value of -1 is returned, and errno set to indicate the error.
  32.  
  33. ------------------------------------------------------------------------------*/
  34. /* array data type import macro */
  35. #define vimp(FP, P, N, TYPE, IMPFCT) {                    \
  36.     int i = 0;                            \
  37.     TYPE *cp = (TYPE *)(P);                        \
  38.                                     \
  39.     for (i = 0; i < ((N) / sizeof(*cp) - 1); i++) {            \
  40.         if ((IMPFCT)((FP), cp, (N)) == -1) return -1;        \
  41.         cp++;                            \
  42.     }                                \
  43. }
  44.  
  45. #define MAXFLDLEN    (1024)
  46. static char s[MAXFLDLEN + 1];
  47.  
  48. static int getfld(fp)
  49. FILE *fp;
  50. {
  51.     int i = 0;
  52.     int c = 0;
  53.  
  54.     memset(s, 0, sizeof(s));
  55.     for (i = 0; ; i++) {
  56.         c = fgetc(fp);
  57.         if (ferror(fp)) {
  58.             return -1;
  59.         }
  60.         if (feof(fp)) {
  61.             break;
  62.         }
  63.         if ((c == EXPFLDDLM) || (c == EXPRECDLM)) {
  64.             break;
  65.         }
  66.         if (i >= sizeof(s) - 1) {
  67.             return -1;
  68.         }
  69.         s[i] = c;
  70.     }
  71.     s[i] = '\0';
  72.  
  73.     return 0;
  74. }
  75.  
  76. #define charimp        (ucharimp)
  77.  
  78. #define charvimp    (ucharvimp)
  79.  
  80. static int ucharimp(fp, p, n)
  81. FILE *fp;
  82. CONST void *p;
  83. size_t n;
  84. {
  85.     int c = 0;
  86.  
  87.     if (getfld(fp) == -1) {
  88.         return -1;
  89.     }
  90.     c = (unsigned char)s[0];
  91.     if (c == EXPESC) {
  92.         switch ((unsigned char)s[1]) {
  93.         case '\0':    /* premature end of field */
  94.             return -1;
  95.             break;    /* case '\0': */
  96. #if __STDC__ == 1
  97.         case 'a':    /* audible alert */
  98.             c = '\a';
  99.             break;    /* case 'a': */
  100. #endif
  101.         case 'b':    /* backspace */
  102.             c = '\b';
  103.             break;    /* case 'b': */
  104.         case 'f':    /* form feed */
  105.             c = '\f';
  106.             break;    /* case 'f': */
  107.         case 'n':    /* newline */
  108.             c = '\n';
  109.             break;    /* case 'n': */
  110.         case 'r':    /* carriage return */
  111.             c = '\r';
  112.             break;    /* case 'r': */
  113.         case 't':    /* horizontal tab */
  114.             c = '\t';
  115.             break;    /* case 't': */
  116.         case 'v':    /* vertical tab */
  117.             c = '\v';
  118.             break;    /* case 'v': */
  119.         default:    /* */
  120.             if (isodigit(s[1])) {
  121.                 if (!isodigit(s[2]) || !isodigit(s[3])) return -1;
  122.                 if (sscanf(s, "%3o", &c) != 1) return -1;
  123.             } else {
  124.                 c = (unsigned char)s[1];
  125.             }
  126.             break;    /* default: */
  127.         }
  128.     }
  129.     *(unsigned char *)p = c;
  130.  
  131.     return 0;
  132. }
  133.  
  134. static int ucharvimp(fp, p, n)
  135. FILE *fp;
  136. CONST void *p;
  137. size_t n;
  138. {
  139.     vimp(fp, p, n, unsigned char, ucharimp);
  140.  
  141.     return 0;
  142. }
  143.  
  144. static int shortimp(fp, p, n)
  145. FILE *fp;
  146. CONST void *p;
  147. size_t n;
  148. {
  149.     if (getfld(fp) == -1) {
  150.         return -1;
  151.     }
  152.     if (sscanf(s, "%hd", (short *)p) != 1) return -1;
  153.  
  154.     return 0;
  155. }
  156.  
  157. static int shortvimp(fp, p, n)
  158. FILE *fp;
  159. CONST void *p;
  160. size_t n;
  161. {
  162.     vimp(fp, p, n, SIGNED short, shortimp);
  163.  
  164.     return 0;
  165. }
  166.  
  167. static int ushortimp(fp, p, n)
  168. FILE *fp;
  169. CONST void *p;
  170. size_t n;
  171. {
  172.     if (getfld(fp) == -1) {
  173.         return -1;
  174.     }
  175.     if (sscanf(s, "%hu", (unsigned short *)p) != 1) return -1;
  176.  
  177.     return 0;
  178. }
  179.  
  180. static int ushortvimp(fp, p, n)
  181. FILE *fp;
  182. CONST void *p;
  183. size_t n;
  184. {
  185.     vimp(fp, p, n, unsigned short, ushortimp);
  186.  
  187.     return 0;
  188. }
  189.  
  190. static int intimp(fp, p, n)
  191. FILE *fp;
  192. CONST void *p;
  193. size_t n;
  194. {
  195.     if (getfld(fp) == -1) {
  196.         return -1;
  197.     }
  198.     if (sscanf(s, "%d", (int *)p) != 1) return -1;
  199.  
  200.     return 0;
  201. }
  202.  
  203. static int intvimp(fp, p, n)
  204. FILE *fp;
  205. CONST void *p;
  206. size_t n;
  207. {
  208.     vimp(fp, p, n, SIGNED int, intimp);
  209.  
  210.     return 0;
  211. }
  212.  
  213. static int uintimp(fp, p, n)
  214. FILE *fp;
  215. CONST void *p;
  216. size_t n;
  217. {
  218.     if (getfld(fp) == -1) {
  219.         return -1;
  220.     }
  221.     if (sscanf(s, "%u", (unsigned int *)p) != 1) return -1;
  222.  
  223.     return 0;
  224. }
  225.  
  226. static int uintvimp(fp, p, n)
  227. FILE *fp;
  228. CONST void *p;
  229. size_t n;
  230. {
  231.     vimp(fp, p, n, unsigned int, uintimp);
  232.  
  233.     return 0;
  234. }
  235.  
  236. static int longimp(fp, p, n)
  237. FILE *fp;
  238. CONST void *p;
  239. size_t n;
  240. {
  241.     if (getfld(fp) == -1) {
  242.         return -1;
  243.     }
  244.     if (sscanf(s, "%ld", (long *)p) != 1) return -1;
  245.  
  246.     return 0;
  247. }
  248.  
  249. static int longvimp(fp, p, n)
  250. FILE *fp;
  251. CONST void *p;
  252. size_t n;
  253. {
  254.     vimp(fp, p, n, SIGNED long, longimp);
  255.  
  256.     return 0;
  257. }
  258.  
  259. static int ulongimp(fp, p, n)
  260. FILE *fp;
  261. CONST void *p;
  262. size_t n;
  263. {
  264.     if (getfld(fp) == -1) {
  265.         return -1;
  266.     }
  267.     if (sscanf(s, "%lu", (unsigned long *)p) != 1) return -1;
  268.  
  269.     return 0;
  270. }
  271.  
  272. static int ulongvimp(fp, p, n)
  273. FILE *fp;
  274. CONST void *p;
  275. size_t n;
  276. {
  277.     vimp(fp, p, n, unsigned long, ulongimp);
  278.  
  279.     return 0;
  280. }
  281.  
  282. static int floatimp(fp, p, n)
  283. FILE *fp;
  284. CONST void *p;
  285. size_t n;
  286. {
  287.     if (getfld(fp) == -1) {
  288.         return -1;
  289.     }
  290.     if (sscanf(s, "%g", (float *)p) != 1) return -1;
  291.  
  292.     return 0;
  293. }
  294.  
  295. static int floatvimp(fp, p, n)
  296. FILE *fp;
  297. CONST void *p;
  298. size_t n;
  299. {
  300.     vimp(fp, p, n, float, floatimp);
  301.  
  302.     return 0;
  303. }
  304.  
  305. static int doubleimp(fp, p, n)
  306. FILE *fp;
  307. CONST void *p;
  308. size_t n;
  309. {
  310.     if (getfld(fp) == -1) {
  311.         return -1;
  312.     }
  313.     if (sscanf(s, "%lg", (double *)p) != 1) return -1;
  314.  
  315.     return 0;
  316. }
  317.  
  318. static int doublevimp(fp, p, n)
  319. FILE *fp;
  320. CONST void *p;
  321. size_t n;
  322. {
  323.     vimp(fp, p, n, double, doubleimp);
  324.  
  325.     return 0;
  326. }
  327.  
  328. static int ldoubleimp(fp, p, n)
  329. FILE *fp;
  330. CONST void *p;
  331. size_t n;
  332. {
  333.     if (getfld(fp) == -1) {
  334.         return -1;
  335.     }
  336.     if (sscanf(s, "%Lg", (LDOUBLE *)p) != 1) return -1;
  337.  
  338.     return 0;
  339. }
  340.  
  341. static int ldoublevimp(fp, p, n)
  342. FILE *fp;
  343. CONST void *p;
  344. size_t n;
  345. {
  346.     vimp(fp, p, n, LDOUBLE, ldoubleimp);
  347.  
  348.     return 0;
  349. }
  350.  
  351. static int pointerimp(fp, p, n)
  352. FILE *fp;
  353. CONST void *p;
  354. size_t n;
  355. {
  356.     if (getfld(fp) == -1) {
  357.         return -1;
  358.     }
  359.     if (sscanf(s, "%p", (void **)p) != 1) return -1;
  360.  
  361.     return 0;
  362. }
  363.  
  364. static int pointervimp(fp, p, n)
  365. FILE *fp;
  366. CONST void *p;
  367. size_t n;
  368. {
  369.     vimp(fp, p, n, void *, pointerimp);
  370.  
  371.     return 0;
  372. }
  373.  
  374. static int stringimp(fp, p, n)
  375. FILE *fp;
  376. CONST void *p;
  377. size_t n;
  378. {
  379.     unsigned char *si = NULL;
  380.     int i = 0;
  381.     int c = 0;
  382.  
  383.     if (getfld(fp) == -1) {
  384.         return -1;
  385.     }
  386.  
  387.     /* initialize return */
  388.     memset(p, 0, n);
  389.  
  390.     /* convert */ /* string will be truncated if too long */
  391.     si = (unsigned char *)s;
  392.     for (i = 0; i < n - 1; i++) {
  393.         c = *si++;
  394.         if (c == '\0') {
  395.             *((char *)p + i) = '\0';
  396.             break;
  397.         }
  398.         if (c == EXPESC) {
  399.             switch (*si) {
  400.             case '\0':    /* premature end of field */
  401.                 return -1;
  402.                 break;    /* case '\0': */
  403. #if __STDC__ == 1
  404.             case 'a':    /* audible alert */
  405.                 c = '\a';
  406.                 break;    /* case 'a': */
  407. #endif
  408.             case 'b':    /* backspace */
  409.                 c = '\b';
  410.                 break;    /* case 'b': */
  411.             case 'f':    /* form feed */
  412.                 c = '\f';
  413.                 break;    /* case 'f': */
  414.             case 'n':    /* newline */
  415.                 c = '\n';
  416.                 break;    /* case 'n': */
  417.             case 'r':    /* carriage return */
  418.                 c = '\r';
  419.                 break;    /* case 'r': */
  420.             case 't':    /* horizontal tab */
  421.                 c = '\t';
  422.                 break;    /* case 't': */
  423.             case 'v':    /* vertical tab */
  424.                 c = '\v';
  425.                 break;    /* case 'v': */
  426.             default:    /* */
  427.                 if (isodigit(*si)) {
  428.                     if (!isodigit(*(si + 1)) || !isodigit(*(si + 2))) return -1;
  429.                     if (sscanf(si, "%3o", &c) != 1) return -1;
  430.                     si += 2;
  431.                 } else {
  432.                     c = *si;
  433.                 }
  434.                 break;    /* default: */
  435.             }
  436.             si++;
  437.         }
  438.         *((char *)p + i) = c;
  439.     }
  440.     *((char *)p + n - 1) = '\0';
  441.  
  442.     return 0;
  443. }
  444.  
  445. static int binaryimp(fp, p, n)
  446. FILE *fp;
  447. CONST void *p;
  448. size_t n;
  449. {
  450.     /* calculate number of hex digits for each char
  451.          # bits in char == CHAR_BIT, # bits in hex digit == 4 */
  452.     CONST int hexdigits = (CHAR_BIT + (4 - 1)) / 4;
  453.     unsigned char *si = (unsigned char *)s;
  454.     unsigned char *pi = (unsigned char *)p;
  455.     char fmt[24];            /* printf format string */
  456.     int c = 0;
  457.  
  458.     sprintf(fmt, "%%%dX", hexdigits);
  459.  
  460.     if (getfld(fp) == -1) {
  461.         return -1;
  462.     }
  463.  
  464.     /* initialize return */
  465.     memset(p, 0, n);
  466.  
  467.     while (1) {
  468.         if (si - (unsigned char *)s >= sizeof(s) - hexdigits) break;
  469.         if (pi - (unsigned char *)p >= n) break;
  470.         if (sscanf(si, fmt, &c) != 1) return -1;
  471.         si += hexdigits;
  472.         *pi++ = (unsigned char)c;
  473.     }
  474.  
  475.     return 0;
  476. }
  477.  
  478. /* import function table definition */
  479. CONST cbimp_t cbimpv[] = {
  480.     charimp,    /* t_char    =  0 */
  481.     charvimp,    /* t_charv    =  1 */
  482.     ucharimp,    /* t_uchar    =  2 */
  483.     ucharvimp,    /* t_ucharv    =  3 */
  484.     shortimp,    /* t_short    =  4 */
  485.     shortvimp,    /* t_shortv    =  5 */
  486.     ushortimp,    /* t_ushort    =  6 */
  487.     ushortvimp,    /* t_ushortv    =  7 */
  488.     intimp,        /* t_int    =  8 */
  489.     intvimp,    /* t_intv    =  9 */
  490.     uintimp,    /* t_uint    = 10 */
  491.     uintvimp,    /* t_uintv    = 11 */
  492.     longimp,    /* t_long    = 12 */
  493.     longvimp,    /* t_longv    = 13 */
  494.     ulongimp,    /* t_ulong    = 14 */
  495.     ulongvimp,    /* t_ulongv    = 15 */
  496.     floatimp,    /* t_float    = 16 */
  497.     floatvimp,    /* t_floatv    = 17 */
  498.     doubleimp,    /* t_double    = 18 */
  499.     doublevimp,    /* t_doublev    = 19 */
  500.     ldoubleimp,    /* t_ldouble    = 20 */
  501.     ldoublevimp,    /* t_ldoublev    = 21 */
  502.     pointerimp,    /* t_pointer    = 22 */
  503.     pointervimp,    /* t_pointerv    = 23 */
  504.     stringimp,    /* t_string    = 24 */
  505.     binaryimp    /* t_binary    = 25 */
  506. };
  507.