/dx-4.4.4/src/exec/libdx/lbextract.c

# · C · 1185 lines · 816 code · 237 blank · 132 comment · 200 complexity · 95a46cf3b93d40dadc0418c319897fcd MD5 · raw file 

    

  1. /***********************************************************************/
    2. 

  2. /* Open Visualization Data Explorer                                    */
    3. 

  3. /* (C) Copyright IBM Corp. 1989,1999                                   */
    4. 

  4. /* ALL RIGHTS RESERVED                                                 */
    5. 

  5. /* This code licensed under the                                        */
    6. 

  6. /*    "IBM PUBLIC LICENSE - Open Visualization Data Explorer"          */
    7. 

  7. /***********************************************************************/
    8. 

  8. 

  9. #include <dxconfig.h>
    10. 

  10. 

  11. 

  12. 

  13. 

  14. #include <string.h>
    15. 

  15. #include <dx/dx.h>
    16. 

  16. 

  17. 

  18. /*
    19. 

  19.  * simple routines for common cases
    20. 

  20.  */  
    21. 

  21. Object DXExtractInteger(Object o, int *ip)
    22. 

  22. {
    23. 

  23.     return DXExtractParameter(o, TYPE_INT, 0, 1, (Pointer)ip);
    24. 

  24. }
    25. 

  25. 

  26. Object DXExtractFloat(Object o, float *fp)
    27. 

  27. {
    28. 

  28.     return DXExtractParameter(o, TYPE_FLOAT, 0, 1, (Pointer)fp);
    29. 

  29. }
    30. 

  30. 

  31. /* slightly different - it returns a pointer to the start of the string.
    32. 

  32.  *  the caller doesn't need to allocate space for it.
    33. 

  33.  */
    34. 

  34. Object DXExtractString(Object o, char **cp)
    35. 

  35. {
    36. 

  36.     char *c;
    37. 

  37.     int len;
    38. 

  38.     Type t;
    39. 

  39. 

  40.     /* this does the checking to be sure it is either a String object, 
    41. 

  41.      *  or a TYPE_STRING array.
    42. 

  42.      */
    43. 

  43.     if(!DXQueryParameter(o, TYPE_STRING, 1, NULL))
    44. 

  44. 	return NULL;
    45. 

  45. 

  46.     
    47. 

  47.     if(DXGetObjectClass(o) == CLASS_STRING) {
    48. 

  48. 	if (cp)
    49. 

  49. 	    *cp = DXGetString((String)o);
    50. 

  50. 	return o;
    51. 

  51.     }
    52. 

  52.     
    53. 

  53.     DXGetArrayInfo((Array) o, &len, &t, NULL, NULL, NULL);
    54. 

  54.     
    55. 

  55.     if (t == TYPE_STRING) {
    56. 

  56. 	if (len > 1)
    57. 

  57. 	    return NULL;
    58. 

  58. 

  59. 	if (cp)
    60. 

  60. 	    *cp = (char *)DXGetArrayData((Array)o);    
    61. 

  61. 	return o;
    62. 

  62.     }
    63. 

  63. 

  64.     /* for backwards compatibility - TYPE_UBYTE */
    65. 

  65.     c = (char *)DXGetArrayData((Array)o);
    66. 

  66.     
    67. 

  67.     while (--len > 0) {
    68. 

  68. 	
    69. 

  69. 	if (*c++)      /* fail if there are imbedded NULLs... */
    70. 

  70. 	    continue;
    71. 

  71. 	
    72. 

  72. 	return NULL;
    73. 

  73.     }
    74. 

  74. 

  75.     if (*c)            /* ...or if there isn't a trailing NULL */
    76. 

  76. 	return NULL;
    77. 

  77.     
    78. 

  78.     if (cp)
    79. 

  79. 	*cp = (char *)DXGetArrayData((Array)o);    
    80. 

  80.     return o;
    81. 

  81. }
    82. 

  82. 

  83. 

  84. Object DXExtractNthString (Object o, int n, char **cp)
    85. 

  85. {
    86. 

  86.     char *c, *cs;
    87. 

  87.     int	len;
    88. 

  88.     Type type;
    89. 

  89.     int shape;
    90. 

  90. 

  91.     if (n < 0)
    92. 

  92. 	return (NULL);
    93. 

  93. 

  94.     /* only returns ok if object class String or Array TYPE_STRING or UBYTE */
    95. 

  95.     if (! DXQueryParameter (o, TYPE_STRING, 1, NULL))
    96. 

  96. 	return (NULL);
    97. 

  97. 

  98.     if (DXGetObjectClass(o) == CLASS_STRING) {
    99. 

  99. 

  100. 	/* String objects are 1 string, so asking for any string 
    101. 

  101. 	 *  but the 0th is bad. 
    102. 

  102. 	 */
    103. 

  103. 	if (n)
    104. 

  104. 	    return (NULL);
    105. 

  105. 	
    106. 

  106. 	if (cp)
    107. 

  107. 	    *cp = DXGetString ((String) o);
    108. 

  108. 	return (o);
    109. 

  109.     }
    110. 

  110. 

  111.     DXGetArrayInfo ((Array) o, &len, &type, NULL, NULL, NULL);
    112. 

  112.     if (type == TYPE_STRING) {
    113. 

  113. 

  114. 	/* len is number of strings in array */
    115. 

  115. 	if (n >= len)
    116. 

  116. 	    return NULL;
    117. 

  117. 

  118. 	/* the Query call above made sure this is rank 1, 
    119. 

  119. 	 * so shape is safe here 
    120. 

  120. 	 */
    121. 

  121. 	DXGetArrayInfo ((Array) o, NULL, NULL, NULL, NULL, &shape);
    122. 

  122. 	cs = (char *) DXGetArrayData ((Array) o);
    123. 

  123. 

  124. 	if (cp)
    125. 

  125. 	    *cp = cs + (n * shape);
    126. 

  126. 	return o;
    127. 

  127.     }
    128. 

  128. 

  129.     /* here for backward compatibility - 
    130. 

  130.      * null separated chars in a UBYTE array 
    131. 

  131.      */
    132. 

  132.     cs = (char *) DXGetArrayData ((Array) o);
    133. 

  133.     
    134. 

  134.     for (c=cs; len--; ) {
    135. 

  135. 	
    136. 

  136. 	if (*c++)
    137. 

  137. 	    continue;
    138. 

  138. 	
    139. 

  139. 	if (n == 0) {
    140. 

  140. 	    if (cp)
    141. 

  141. 		*cp = cs;
    142. 

  142. 	    return (o);
    143. 

  143. 	}
    144. 

  144. 	
    145. 

  145. 	n--;
    146. 

  146. 	cs = c;
    147. 

  147.     }
    148. 

  148.     
    149. 

  149.     return (NULL);
    150. 

  150. }
    151. 

  151. 

  152. 

  153. /* new code */
    154. 

  154. 

  155. #define CONVTYPE(from, to) \
    156. 

  156. static Error 					\
    157. 

  157. from##2##to(int count, from *fp, to *tp)  	\
    158. 

  158. {                                               \
    159. 

  159.     int i;					\
    160. 

  160. 						\
    161. 

  161.     for (i=0; i<count; i++) 			\
    162. 

  162. 	*tp++ = (to) *fp++; 			\
    163. 

  163. 						\
    164. 

  164.     return OK; 					\
    165. 

  165. }
    166. 

  166. 

  167. CONVTYPE(byte, short)
    168. 

  168. CONVTYPE(byte, int)
    169. 

  169. CONVTYPE(byte, float)
    170. 

  170. CONVTYPE(byte, double)
    171. 

  171. CONVTYPE(ubyte, short )
    172. 

  172. CONVTYPE(ubyte, ushort)
    173. 

  173. CONVTYPE(ubyte, int)
    174. 

  174. CONVTYPE(ubyte, uint)
    175. 

  175. CONVTYPE(ubyte, float)
    176. 

  176. CONVTYPE(ubyte, double)
    177. 

  177. CONVTYPE(short, int)
    178. 

  178. CONVTYPE(short, float)
    179. 

  179. CONVTYPE(short, double)
    180. 

  180. CONVTYPE(ushort, int)
    181. 

  181. CONVTYPE(ushort, uint)
    182. 

  182. CONVTYPE(ushort, float)
    183. 

  183. CONVTYPE(ushort, double)
    184. 

  184. CONVTYPE(int, float)
    185. 

  185. CONVTYPE(int, double)
    186. 

  186. CONVTYPE(uint, float)
    187. 

  187. CONVTYPE(uint, double)
    188. 

  188. CONVTYPE(float, double)
    189. 

  189. 

  190. 

  191. struct convtable {
    192. 

  192.     int conversion;                        /* convert flags */
    193. 

  193.     Error (*convfunc)();                   /* convert routine */
    194. 

  194.                      /* parms are: (int count, Pointer from, Pointer to); */
    195. 

  195.     int hascommon;                         /* has common representation? */
    196. 

  196.     Type commontype;                       /* smallest common representation */
    197. 

  197. };
    198. 

  198. 

  199. /* conversion flags */
    200. 

  200. #define CONV_ILLEGAL  0   /* types don't convert without truncation */
    201. 

  201. #define CONV_ALLOWED  1   /* conversion allowed */
    202. 

  202. #define CONV_EQUAL    2   /* types already same */
    203. 

  203. #define CONV_NOTIMPL  3   /* type not implemented */
    204. 

  204. #define CONV_LOSSY    4   /* conversion may lose precision (not supported) */
    205. 

  205. 

  206. /* table indices for conversion function table */
    207. 

  207. #define NUM_TYPES   11
    208. 

  208. 

  209. #define C_BYTE      0
    210. 

  210. #define C_UBYTE     1
    211. 

  211. #define C_SHORT     2
    212. 

  212. #define C_USHORT    3
    213. 

  213. #define C_INT       4
    214. 

  214. #define C_UINT      5
    215. 

  215. #define C_HYPER     6   /* currently unsupported */
    216. 

  216. #define C_UHYPER    7   /* currently unsupported */
    217. 

  217. #define C_FLOAT     8
    218. 

  218. #define C_DOUBLE    9
    219. 

  219. #define C_LDOUBLE  10   /* currently unsupported */
    220. 

  220. 

  221. #define TYPE_XXXX   TYPE_BYTE  /* fill in value for unimplemented types */
    222. 

  222. 

  223. /* hascommon flags */
    224. 

  224. #define NO_COMMON   0
    225. 

  225. #define HAS_COMMON  1
    226. 

  226. 

  227. 

  228. static char *typename(Type t)
    229. 

  229. {
    230. 

  230.     switch (t) {
    231. 

  231.       case TYPE_BYTE:		return "byte";
    232. 

  232.       case TYPE_UBYTE:		return "ubyte";
    233. 

  233.       case TYPE_SHORT:		return "short";
    234. 

  234.       case TYPE_USHORT:		return "ushort";
    235. 

  235.       case TYPE_INT:		return "int";
    236. 

  236.       case TYPE_UINT:		return "uint";
    237. 

  237.       case TYPE_HYPER:		return "hyper";
    238. 

  238. /*    case TYPE_UHYPER:		return "uhyper";  */
    239. 

  239.       case TYPE_FLOAT:		return "float";
    240. 

  240.       case TYPE_DOUBLE:		return "double";
    241. 

  241. /*    case TYPE_LDOUBLE:	return "ldouble"; */
    242. 

  242.       default:			return "unknown";
    243. 

  243.     }
    244. 

  244.     /* notreached */
    245. 

  245. }
    246. 

  246. 

  247. static int typeindex(Type t)
    248. 

  248. {
    249. 

  249.     switch (t) {
    250. 

  250.       case TYPE_BYTE:		return C_BYTE;
    251. 

  251.       case TYPE_UBYTE:		return C_UBYTE;
    252. 

  252.       case TYPE_SHORT:		return C_SHORT;
    253. 

  253.       case TYPE_USHORT:		return C_USHORT;
    254. 

  254.       case TYPE_INT:		return C_INT;
    255. 

  255.       case TYPE_UINT:		return C_UINT;
    256. 

  256.       case TYPE_HYPER:		return C_HYPER;
    257. 

  257. /*    case TYPE_UHYPER:		return C_UHYPER;  */
    258. 

  258.       case TYPE_FLOAT:		return C_FLOAT;
    259. 

  259.       case TYPE_DOUBLE:		return C_DOUBLE;
    260. 

  260. /*    case TYPE_LDOUBLE:	return C_LDOUBLE; */
    261. 

  261.       default:			return -1;
    262. 

  262.     }
    263. 

  263.     /* notreached */
    264. 

  264. }
    265. 

  265. 

  266. static struct convtable typetable[NUM_TYPES][NUM_TYPES] = 
    267. 

  267. {
    268. 

  268.  /* from BYTE */			                           /* to ... */ 
    269. 

  269.  { { CONV_EQUAL,      NULL,   	    HAS_COMMON,     TYPE_BYTE },     /* BYTE */
    270. 

  270.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UBYTE */
    271. 

  271.    { CONV_ALLOWED,    byte2short,   HAS_COMMON,     TYPE_SHORT },    /* SHORT */
    272. 

  272.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* USHORT */
    273. 

  273.    { CONV_ALLOWED,    byte2int,     HAS_COMMON,     TYPE_INT },      /* INT */
    274. 

  274.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UINT */
    275. 

  275.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    276. 

  276.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UHYPER */
    277. 

  277.    { CONV_ALLOWED,    byte2float,   HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    278. 

  278.    { CONV_ALLOWED,    byte2double,  HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    279. 

  279.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    280. 

  280. 

  281.  /* from UBYTE */			                           /* to ... */ 
    282. 

  282.  { { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* BYTE */
    283. 

  283.    { CONV_EQUAL,	    NULL,   	    HAS_COMMON,     TYPE_UBYTE },    /* UBYTE */
    284. 

  284.    { CONV_ALLOWED,    ubyte2short,    HAS_COMMON,     TYPE_SHORT },    /* SHORT */
    285. 

  285.    { CONV_ALLOWED,    ubyte2ushort,   HAS_COMMON,     TYPE_USHORT },   /* USHORT */
    286. 

  286.    { CONV_ALLOWED,    ubyte2int,      HAS_COMMON,     TYPE_INT },      /* INT */
    287. 

  287.    { CONV_ALLOWED,    ubyte2uint,     HAS_COMMON,     TYPE_UINT },     /* UINT */
    288. 

  288.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    289. 

  289.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UHYPER */
    290. 

  290.    { CONV_ALLOWED,    ubyte2float,    HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    291. 

  291.    { CONV_ALLOWED,    ubyte2double,   HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    292. 

  292.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    293. 

  293. 

  294.  /* from SHORT */			                           /* to ... */ 
    295. 

  295.  { { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_SHORT },    /* BYTE */
    296. 

  296.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_SHORT },    /* UBYTE */
    297. 

  297.    { CONV_EQUAL,	    NULL,   	    HAS_COMMON,     TYPE_SHORT },    /* SHORT */
    298. 

  298.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* USHORT */
    299. 

  299.    { CONV_ALLOWED,    short2int,      HAS_COMMON,     TYPE_INT },      /* INT */
    300. 

  300.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UINT */
    301. 

  301.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    302. 

  302.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UHYPER */
    303. 

  303.    { CONV_ALLOWED,    short2float,    HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    304. 

  304.    { CONV_ALLOWED,    short2double,   HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    305. 

  305.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    306. 

  306. 

  307.  /* from USHORT */			                           /* to ... */ 
    308. 

  308.  { { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* BYTE */
    309. 

  309.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_USHORT },   /* UBYTE */
    310. 

  310.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* SHORT */
    311. 

  311.    { CONV_EQUAL,	    NULL,   	    HAS_COMMON,     TYPE_USHORT },   /* USHORT */
    312. 

  312.    { CONV_ALLOWED,    ushort2int,     HAS_COMMON,     TYPE_INT },      /* INT */
    313. 

  313.    { CONV_ALLOWED,    ushort2uint,    HAS_COMMON,     TYPE_UINT },     /* UINT */
    314. 

  314.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    315. 

  315.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UHYPER */
    316. 

  316.    { CONV_ALLOWED,    ushort2float,   HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    317. 

  317.    { CONV_ALLOWED,    ushort2double,  HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    318. 

  318.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX }, },  /* LDOUBLE */
    319. 

  319. 

  320.  /* from INT */			                                   /* to ... */ 
    321. 

  321.  { { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_INT },      /* BYTE */
    322. 

  322.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_INT },      /* UBYTE */
    323. 

  323.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_INT },      /* SHORT */
    324. 

  324.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_INT },      /* USHORT */
    325. 

  325.    { CONV_EQUAL,	    NULL,   	    HAS_COMMON,     TYPE_INT },      /* INT */
    326. 

  326.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UINT */
    327. 

  327.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    328. 

  328.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UHYPER */
    329. 

  329.    { CONV_ALLOWED,    int2float,      HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    330. 

  330.    { CONV_ALLOWED,    int2double,     HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    331. 

  331.    { CONV_NOTIMPL,    NULL,	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    332. 

  332. 

  333.  /* from UINT */			                           /* to ... */ 
    334. 

  334.  { { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* BYTE */
    335. 

  335.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_UBYTE },    /* UBYTE */
    336. 

  336.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* SHORT */
    337. 

  337.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_USHORT },   /* USHORT */
    338. 

  338.    { CONV_ILLEGAL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* INT */
    339. 

  339.    { CONV_EQUAL,	    NULL,   	    HAS_COMMON,     TYPE_UINT },     /* UINT */
    340. 

  340.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    341. 

  341.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UHYPER */
    342. 

  342.    { CONV_ALLOWED,    uint2float,     HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    343. 

  343.    { CONV_ALLOWED,    uint2double,    HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    344. 

  344.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX }, },  /* LDOUBLE */
    345. 

  345. 

  346.  /* from HYPER */			                           /* to ... */ 
    347. 

  347.  { { CONV_NOTIMPL,    NULL,   	    HAS_COMMON,     TYPE_HYPER },    /* BYTE */
    348. 

  348.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* UBYTE */
    349. 

  349.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* SHORT */
    350. 

  350.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* USHORT */
    351. 

  351.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* INT */
    352. 

  352.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* UINT */
    353. 

  353.    { CONV_EQUAL,	    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* HYPER */
    354. 

  354.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* UHYPER */
    355. 

  355.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    356. 

  356.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    357. 

  357.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX }, },  /* LDOUBLE */
    358. 

  358. 

  359.  /* from UHYPER */			                           /* to ... */ 
    360. 

  360.  { { CONV_NOTIMPL,    NULL,   	     NO_COMMON,     TYPE_BYTE },     /* BYTE */
    361. 

  361.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* UBYTE */
    362. 

  362.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* SHORT */
    363. 

  363.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* USHORT */
    364. 

  364.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* INT */
    365. 

  365.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_HYPER },    /* UINT */
    366. 

  366.    { CONV_NOTIMPL,    NULL,  	     NO_COMMON,     TYPE_BYTE },     /* HYPER */
    367. 

  367.    { CONV_EQUAL,	    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UHYPER */
    368. 

  368.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    369. 

  369.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    370. 

  370.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX }, },  /* LDOUBLE */
    371. 

  371. 

  372.  /* from FLOAT */			                           /* to ... */ 
    373. 

  373.  { { CONV_ILLEGAL,    NULL,   	    HAS_COMMON,     TYPE_FLOAT },    /* BYTE */
    374. 

  374.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* UBYTE */
    375. 

  375.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* SHORT */
    376. 

  376.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* USHORT */
    377. 

  377.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* INT */
    378. 

  378.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* UINT */
    379. 

  379.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* HYPER */
    380. 

  380.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* UHYPER */
    381. 

  381.    { CONV_EQUAL,	    NULL,  	    HAS_COMMON,     TYPE_FLOAT },    /* FLOAT */
    382. 

  382.    { CONV_ALLOWED,    float2double,   HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    383. 

  383.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    384. 

  384. 

  385.  /* from DOUBLE */			                           /* to ... */ 
    386. 

  386.  { { CONV_ILLEGAL,    NULL,   	    HAS_COMMON,     TYPE_DOUBLE },   /* BYTE */
    387. 

  387.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* UBYTE */
    388. 

  388.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* SHORT */
    389. 

  389.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* USHORT */
    390. 

  390.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* INT */
    391. 

  391.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* UINT */
    392. 

  392.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* HYPER */
    393. 

  393.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* UHYPER */
    394. 

  394.    { CONV_ILLEGAL,    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* FLOAT */ 
    395. 

  395.    { CONV_EQUAL,	    NULL,  	    HAS_COMMON,     TYPE_DOUBLE },   /* DOUBLE */
    396. 

  396.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    397. 

  397. 

  398.  /* from LDOUBLE */			                           /* to ... */ 
    399. 

  399.  { { CONV_NOTIMPL,    NULL,   	    HAS_COMMON,     TYPE_XXXX },     /* BYTE */
    400. 

  400.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UBYTE */
    401. 

  401.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* SHORT */
    402. 

  402.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* USHORT */
    403. 

  403.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* INT */
    404. 

  404.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UINT */
    405. 

  405.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* HYPER */
    406. 

  406.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* UHYPER */
    407. 

  407.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* FLOAT */ 
    408. 

  408.    { CONV_NOTIMPL,    NULL,  	    HAS_COMMON,     TYPE_XXXX },     /* DOUBLE */
    409. 

  409.    { CONV_NOTIMPL,    NULL, 	    HAS_COMMON,     TYPE_XXXX },  }, /* LDOUBLE */
    410. 

  410. };
    411. 

  411. 

  412. 

  413. /* these could probably be macro-ized somehow */
    414. 

  414. /* THESE MUST WORK INPLACE!!! */
    415. 

  415. 

  416. #define INC(ptr, size)  (Pointer)((long)(ptr) + (size))
    417. 

  417. #define DEC(ptr, size)  (Pointer)((long)(ptr) - (size))
    418. 

  418. 

  419. /* conversion is:  a -> a + 0i */
    420. 

  420. static Error real2complex(int count, Pointer from, Pointer to, int itemsize)
    421. 

  421. {
    422. 

  422.     int i;
    423. 

  423.     Pointer efrom, eto;
    424. 

  424. 

  425.     efrom = INC(from, itemsize * (count-1));
    426. 

  426.     eto = INC(to, 2 * itemsize * (count-1));
    427. 

  427.     for (i=count; i>0; i--) {
    428. 

  428. 	memset(eto, '\0', itemsize);
    429. 

  429. 	eto = DEC(to, itemsize);
    430. 

  430. 	memcpy(efrom, eto, itemsize);
    431. 

  431. 	efrom = DEC(from, itemsize);
    432. 

  432. 	eto = DEC(to, itemsize);
    433. 

  433.     }
    434. 

  434. 

  435.     return OK;
    436. 

  436. }
    437. 

  437. 

  438. /* conversion is:  a -> a + 0i + 0j + 0k */
    439. 

  439. static Error real2quatern(int count, Pointer from, Pointer to, int itemsize)
    440. 

  440. {
    441. 

  441.     int i;
    442. 

  442. 

  443.     /*efrom = INC(from, itemsize * (count-1));*/
    444. 

  444.     /*eto = INC(to, 4 * itemsize * (count-1));*/
    445. 

  445.     for (i=count; i>0; i--) {
    446. 

  446. 	memset(to, '\0', 3 * itemsize);
    447. 

  447. 	to = DEC(to, 3 * itemsize);
    448. 

  448. 	memcpy(from, to, itemsize);
    449. 

  449. 	from = DEC(from, itemsize);
    450. 

  450. 	to = DEC(to, itemsize);
    451. 

  451.     }
    452. 

  452. 

  453.     return OK;
    454. 

  454. }
    455. 

  455. 

  456. /* conversion is:  a + bi  ->  a + bi + 0j + 0k */
    457. 

  457. static Error complex2quatern(int count, Pointer from, Pointer to, int itemsize)
    458. 

  458. {
    459. 

  459.     int i;
    460. 

  460. 

  461.     /*efrom = INC(from, itemsize * (count-1));*/
    462. 

  462.     /*eto = INC(from, 2 * itemsize * (count-1));*/
    463. 

  463.     for (i=count; i>0; i--) {
    464. 

  464. 	memset(to, '\0', itemsize);
    465. 

  465. 	to = DEC(to, itemsize);
    466. 

  466. 	memcpy(from, to, itemsize);
    467. 

  467. 	from = DEC(from, itemsize);
    468. 

  468. 	to = DEC(to, itemsize);
    469. 

  469.     }
    470. 

  470. 

  471.     return OK;
    472. 

  472. }
    473. 

  473. 

  474. 

  475. struct convtable2 {
    476. 

  476.     int conversion;
    477. 

  477.     Error (*convfunc)(int count, Pointer from, Pointer to, int itemsize);
    478. 

  478.     int hascommon;
    479. 

  479.     Category commoncat;
    480. 

  480. };
    481. 

  481. 

  482. /* (uses same conversion flags as above) */
    483. 

  483. 

  484. #define NUM_CATS    3
    485. 

  485. 

  486. #define C_REAL	    0
    487. 

  487. #define C_COMPLEX   1
    488. 

  488. #define C_QUATERN   2
    489. 

  489. 

  490. static char *catname(Category c)
    491. 

  491. {
    492. 

  492.     switch (c) {
    493. 

  493.       case CATEGORY_REAL:	return "real";
    494. 

  494.       case CATEGORY_COMPLEX:	return "complex";
    495. 

  495.       case CATEGORY_QUATERNION:	return "quaternion";
    496. 

  496.       default:			return "unknown";
    497. 

  497.     }
    498. 

  498.     /* notreached */
    499. 

  499. }
    500. 

  500. 

  501. static int catindex(Category c)
    502. 

  502. {
    503. 

  503.     switch (c) {
    504. 

  504.       case CATEGORY_REAL:	return C_REAL;
    505. 

  505.       case CATEGORY_COMPLEX:	return C_COMPLEX;
    506. 

  506.       case CATEGORY_QUATERNION:	return C_QUATERN;
    507. 

  507.       default:			return -1;
    508. 

  508.     }
    509. 

  509.     /* notreached */
    510. 

  510. }
    511. 

  511. 

  512. 

  513. static struct convtable2 cattable[NUM_CATS][NUM_CATS] = 
    514. 

  514. {
    515. 

  515.  /* from REAL */			                                /* to ... */ 
    516. 

  516.  { { CONV_EQUAL,  NULL, 	 HAS_COMMON,  CATEGORY_REAL },          /* REAL */
    517. 

  517.    { CONV_ALLOWED, real2complex, HAS_COMMON,  CATEGORY_COMPLEX },       /* COMPLEX */
    518. 

  518.    { CONV_ALLOWED, real2quatern, HAS_COMMON,  CATEGORY_QUATERNION }, }, /* QUATERN */
    519. 

  519. 

  520.  /* from COMPLEX */		 	                                /* to ... */ 
    521. 

  521.  { { CONV_ILLEGAL,  NULL,   	 HAS_COMMON,  CATEGORY_COMPLEX },       /* REAL */
    522. 

  522.    { CONV_EQUAL,  NULL,  	 HAS_COMMON,  CATEGORY_COMPLEX },       /* COMPLEX */
    523. 

  523.    { CONV_ALLOWED, complex2quatern, HAS_COMMON, CATEGORY_QUATERNION }, }, /* QUATERN */
    524. 

  524. 

  525.  /* from QUATERN */			                                /* to ... */ 
    526. 

  526.  { { CONV_ILLEGAL,  NULL,   	HAS_COMMON,  CATEGORY_QUATERNION },     /* REAL */
    527. 

  527.    { CONV_ILLEGAL,  NULL,  	HAS_COMMON,  CATEGORY_QUATERNION },     /* COMPLEX */
    528. 

  528.    { CONV_EQUAL,  NULL,  	HAS_COMMON,  CATEGORY_QUATERNION }, },  /* QUATERN */
    529. 

  529. };
    530. 

  530. 

  531. /* this modifies shape in place to squeeze out shapes of 1
    532. 

  532.  *  (e.g. rank 3, shape 3 1 4 ->  rank 2 shape 3 4)
    533. 

  533.  */
    534. 

  534. static void SqueezeShape(int *rank, int *shape)
    535. 

  535. {
    536. 

  536.     int i, j;
    537. 

  537. 

  538.     i = 0;
    539. 

  539.     while (i < *rank) {
    540. 

  540. 	if (shape[i] > 1)
    541. 

  541. 	    i++;
    542. 

  542. 	else {
    543. 

  543.             (*rank)--;
    544. 

  544.             for (j=i; j<*rank; j++)
    545. 

  545.                 shape[j] = shape[j+1];
    546. 

  546.         } 
    547. 

  547.     }
    548. 

  548.   
    549. 

  549. }
    550. 

  550. 

  551. /* this checks to see if it can squeeze the first rank/shape pair
    552. 

  552.  *  to match the second, and if it can, it modifies them in place
    553. 

  553.  *  and returns OK.  otherwise it leaves them alone and returns ERROR
    554. 

  554.  *  and sets the error code. 
    555. 

  555.  * if it has to expand to match, it adds shape 1 at the end of the list.
    556. 

  556.  *
    557. 

  557.  * this routine isn't done yet.
    558. 

  558.  */
    559. 

  559. 

  560. #if 0
    561. 

  561. static Error SqueezeToShape(int *rank, int *shape, int trank, int *tshape)
    562. 

  562. {
    563. 

  563.     int i, j;
    564. 

  564. 

  565.     i = 0;
    566. 

  566.     while (i < *rank) {
    567. 

  567. 	if (shape[i] > 1)
    568. 

  568. 	    i++;
    569. 

  569. 	else {
    570. 

  570.             (*rank)--;
    571. 

  571.             for (j=i; j<*rank; j++)
    572. 

  572.                 shape[j] = shape[j+1];
    573. 

  573.         } 
    574. 

  574.     }
    575. 

  575. 

  576.     return ERROR;
    577. 

  577. }
    578. 

  578. #endif
    579. 

  579. 

  580. static Error
    581. 

  581. ConvertArrayContents(Array from, Array to, int squeeze)
    582. 

  582. {
    583. 

  583.     int i;
    584. 

  584.     int fi, ti;
    585. 

  585.     Pointer fromdp, todp;
    586. 

  586.     int count;
    587. 

  587.     int fromcount, tocount;
    588. 

  588.     Type fromtype, totype;
    589. 

  589.     Category fromcat, tocat;
    590. 

  590.     int fromrank, torank;
    591. 

  591.     int fromshape[100], toshape[100];
    592. 

  592. 

  593.     DXGetArrayInfo(from, &fromcount, &fromtype, &fromcat, &fromrank, fromshape);
    594. 

  594.     DXGetArrayInfo(to, &tocount, &totype, &tocat, &torank, toshape);
    595. 

  595. 

  596.     if (fromcount != tocount)
    597. 

  597. 	DXErrorReturn(ERROR_DATA_INVALID, "array sizes don't match");
    598. 

  598. 

  599. 

  600.     /* squeeze out shapes of 1 from both and make sure they match. */
    601. 

  601.     if (squeeze) {
    602. 

  602. 	SqueezeShape(&fromrank, fromshape);
    603. 

  603. 	SqueezeShape(&torank, toshape);
    604. 

  604.     }
    605. 

  605. 

  606.     if (fromrank != torank) {
    607. 

  607. 	if (squeeze)
    608. 

  608. 	    DXErrorReturn(ERROR_DATA_INVALID, "data ranks don't match");
    609. 

  609. 

  610. 	return ConvertArrayContents(from, to, 1);
    611. 

  611.     }
    612. 

  612. 

  613.     for (i=0; i<fromrank; i++)
    614. 

  614. 	if (fromshape[i] != toshape[i]) {
    615. 

  615. 	    if (squeeze)
    616. 

  616. 		DXErrorReturn(ERROR_DATA_INVALID, "data shapes don't match");
    617. 

  617. 

  618. 	    return ConvertArrayContents(from, to, 1);
    619. 

  619. 	}
    620. 

  620. 

  621. 

  622.     if (((fi = typeindex(fromtype)) < 0) || ((ti = typeindex(totype)) < 0))
    623. 

  623.         DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    624. 

  624.     
    625. 

  625.     fromdp = DXGetArrayData(from);
    626. 

  626.     todp = DXGetArrayData(to);
    627. 

  627. 

  628.     switch (typetable[fi][ti].conversion) {
    629. 

  629.       case CONV_EQUAL:
    630. 

  630.         memcpy(todp, fromdp, fromcount * DXGetItemSize(from));
    631. 

  631.         break;
    632. 

  632.         
    633. 

  633.       case CONV_ALLOWED:
    634. 

  634. 	count = fromcount * (DXGetItemSize(from) / DXTypeSize(fromtype));
    635. 

  635.         if ((typetable[fi][ti].convfunc)(count, fromdp, todp) == ERROR)
    636. 

  636.             DXErrorReturn(ERROR_DATA_INVALID, "type conversion failed");
    637. 

  637.         
    638. 

  638.         break;
    639. 

  639.         
    640. 

  640.       case CONV_NOTIMPL:
    641. 

  641.       default:
    642. 

  642.         DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    643. 

  643.         
    644. 

  644.       case CONV_ILLEGAL:
    645. 

  645.       case CONV_LOSSY:
    646. 

  646.         DXSetError(ERROR_DATA_INVALID, "cannot convert %s to %s", 
    647. 

  647.                    typename(fromtype), typename(totype));
    648. 

  648.         return ERROR;
    649. 

  649.         
    650. 

  650.     }
    651. 

  651.     
    652. 

  652.     if (((fi = catindex(fromcat)) < 0) || ((ti = catindex(tocat)) < 0))
    653. 

  653.         DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    654. 

  654.     
    655. 

  655.     switch (cattable[fi][ti].conversion) {
    656. 

  656.       case CONV_EQUAL:
    657. 

  657.         break;
    658. 

  658.         
    659. 

  659.       case CONV_ALLOWED:
    660. 

  660. 	count = fromcount * (DXGetItemSize(from) / DXCategorySize(fromcat));
    661. 

  661.         if ((cattable[fi][ti].convfunc)(count, todp, todp, 
    662. 

  662.                                         DXGetItemSize(from)) == ERROR)
    663. 

  663.             DXErrorReturn(ERROR_DATA_INVALID, "category conversion failed");
    664. 

  664.         
    665. 

  665.         break;
    666. 

  666.         
    667. 

  667.       case CONV_NOTIMPL:
    668. 

  668.       default:
    669. 

  669.         DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    670. 

  670.         
    671. 

  671.       case CONV_ILLEGAL:
    672. 

  672.       case CONV_LOSSY:
    673. 

  673.         DXSetError(ERROR_NOT_IMPLEMENTED, "cannot convert %s to %s", 
    674. 

  674.                    catname(fromcat), catname(tocat));
    675. 

  675.         return ERROR;
    676. 

  676.     }
    677. 

  677. 

  678.     return OK;
    679. 

  679. }
    680. 

  680. 

  681. 

  682. static Array 
    683. 

  683. ArrayConvert(Array a, Type t, Category c, int rank, int *shape)
    684. 

  684. {
    685. 

  685.     int i;
    686. 

  686.     Array out;
    687. 

  687. 

  688.     ASSERT(rank<100);
    689. 

  689. 

  690.     out = DXNewArrayV(t, c, rank, shape);
    691. 

  691.     
    692. 

  692.     DXGetArrayInfo(a, &i, NULL, NULL, NULL, NULL);
    693. 

  693.     if (!DXAddArrayData(out, 0, i, NULL))
    694. 

  694. 	return NULL;
    695. 

  695. 

  696.     if (!ConvertArrayContents(a, out, 0)) {
    697. 

  697. 	DXDelete((Object)out);
    698. 

  698. 	return NULL;
    699. 

  699.     }
    700. 

  700. 

  701.     return out;
    702. 

  702. }
    703. 

  703. 

  704. 

  705. Array 
    706. 

  706. DXArrayConvert(Array a, Type t, Category c, int rank, ... )
    707. 

  707. {
    708. 

  708.     int i;
    709. 

  709.     int shape[100];
    710. 

  710.     va_list arg;
    711. 

  711. 

  712.     ASSERT(rank<100);
    713. 

  713. 

  714.     /* collect args */
    715. 

  715.     va_start(arg,rank);       /* no spaces allowed - this is a weird macro */
    716. 

  716.     for (i=0; i<rank; i++)
    717. 

  717. 	shape[i] = va_arg(arg, int);
    718. 

  718.     va_end(arg);
    719. 

  719. 

  720.     /* common code with V version. */
    721. 

  721.     return ArrayConvert(a, t, c, rank, shape);
    722. 

  722. }
    723. 

  723. 

  724. 

  725. Array 
    726. 

  726. DXArrayConvertV(Array a, Type t, Category c, int rank, int *shape)
    727. 

  727. {
    728. 

  728.     return ArrayConvert(a, t, c, rank, shape);
    729. 

  729. }
    730. 

  730. 

  731. 

  732. /* sees if there is a common format and returns it.  otherwise returns
    733. 

  733.  *  NULL but and sets error code.
    734. 

  734.  */
    735. 

  735. static Error
    736. 

  736. QueryArrayCommon(Type *t, Category *c, int *rank, int *shape, int n, 
    737. 

  737. 		 Array *a, int squeeze)
    738. 

  738. {
    739. 

  739.     int i, j;
    740. 

  740.     int ni, cti, cci;
    741. 

  741.     Type nextt, comt;
    742. 

  742.     Category nextc, comc;
    743. 

  743.     int nextrank, comrank;
    744. 

  744.     int nextshape[100], comshape[100];
    745. 

  745. 

  746.     ASSERT(n<100);
    747. 

  747. 

  748.     if (n <= 0) {
    749. 

  749. 	DXSetError(ERROR_DATA_INVALID, 
    750. 

  750.                    "array list count must be a positive integer");
    751. 

  751. 	return ERROR;
    752. 

  752.     }
    753. 

  753. 

  754.     if (!DXGetArrayInfo(a[0], NULL, &comt, &comc, &comrank, comshape))
    755. 

  755. 	return ERROR;
    756. 

  756. 

  757.     if (squeeze)
    758. 

  758. 	SqueezeShape(&comrank, comshape);
    759. 

  759. 

  760.   
    761. 

  761.     /* if the values don't match, see if they are compatible, and use
    762. 

  762.      *  the minimum necessary changes.
    763. 

  763.      */
    764. 

  764.     for (i=1; i<n; i++) {
    765. 

  765. 

  766. 	if (!DXGetArrayInfo(a[i], NULL, &nextt, &nextc, &nextrank, nextshape))
    767. 

  767. 	    return ERROR;
    768. 

  768.         
    769. 

  769. 	/* data type */
    770. 

  770. 	if (comt != nextt) {
    771. 

  771.             if ((cti = typeindex(comt)) < 0)
    772. 

  772.                 DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    773. 

  773.     
    774. 

  774.             if ((ni = typeindex(nextt)) < 0)
    775. 

  775.                 DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    776. 

  776. 	
    777. 

  777.             switch (typetable[cti][ni].hascommon) {
    778. 

  778.               case HAS_COMMON:
    779. 

  779.                 comt = typetable[cti][ni].commontype;
    780. 

  780.                 break;
    781. 

  781. 	    
    782. 

  782.               case NO_COMMON:
    783. 

  783.                 DXSetError(ERROR_DATA_INVALID, "no common format for %s and %s", 
    784. 

  784.                            typename(comt), typename(nextt));
    785. 

  785.                 return ERROR;
    786. 

  786.             }
    787. 

  787.             
    788. 

  788.         }
    789. 

  789. 

  790.         /* data category */
    791. 

  791.         if (comc != nextc) {
    792. 

  792.             if ((cci = catindex(comc)) < 0)
    793. 

  793.                 DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    794. 

  794.     
    795. 

  795.             if ((ni = catindex(nextc)) < 0) 
    796. 

  796.                 DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    797. 

  797.             
    798. 

  798.             switch (cattable[cci][ni].hascommon) {
    799. 

  799.               case HAS_COMMON:
    800. 

  800.                 comc = cattable[cci][ni].commoncat;	    
    801. 

  801.                 break;
    802. 

  802. 	    
    803. 

  803.               case NO_COMMON:
    804. 

  804.                 DXSetError(ERROR_DATA_INVALID, "no common format for %s and %s", 
    805. 

  805.                            catname(comc), catname(nextc));
    806. 

  806.                 return ERROR;
    807. 

  807.             }
    808. 

  808.         }
    809. 

  809.         
    810. 

  810.         /* data rank -  squeeze out shapes of 1 */
    811. 

  811. 	if (squeeze)
    812. 

  812. 	    SqueezeShape(&nextrank, nextshape);
    813. 

  813.   
    814. 

  814. 	if (comrank != nextrank) {
    815. 

  815. 	    if (squeeze) {
    816. 

  816. 		DXSetError(ERROR_DATA_INVALID, 
    817. 

  817. 			   "data rank does not match (%d != %d)", 
    818. 

  818. 			   comrank, nextrank);
    819. 

  819. 		return ERROR;
    820. 

  820. 	    }
    821. 

  821. 

  822. 	    return QueryArrayCommon(t, c, rank, shape, n, a, 1);
    823. 

  823. 	}
    824. 

  824. 

  825. 

  826. 

  827. 	for (j=0; j<comrank; j++) {
    828. 

  828. 	    if (comshape[j] != nextshape[j]) {
    829. 

  829. 		if (squeeze) {
    830. 

  830. 		    DXSetError(ERROR_DATA_INVALID, 
    831. 

  831. 			       "data shape %d does not match (%d != %d)", 
    832. 

  832. 			       j, comshape[j], nextshape[j]);
    833. 

  833. 		    
    834. 

  834. 		    return ERROR;
    835. 

  835. 		}
    836. 

  836. 

  837. 		
    838. 

  838. 		return QueryArrayCommon(t, c, rank, shape, n, a, 1);
    839. 

  839. 	    }
    840. 

  840. 	    
    841. 

  841. 	}
    842. 

  842.     }
    843. 

  843. 

  844. 

  845.     /* ok - finally.  return the results */
    846. 

  846.     if (t)
    847. 

  847. 	*t = comt;
    848. 

  848.     if (c)
    849. 

  849. 	*c = comc;
    850. 

  850.     if (rank)
    851. 

  851. 	*rank = comrank;
    852. 

  852.     if (shape) {
    853. 

  853. 	for (i=0; i<comrank; i++)
    854. 

  854. 	    shape[i] = comshape[i];
    855. 

  855.     }
    856. 

  856.     return OK;
    857. 

  857. }
    858. 

  858. 

  859. Error 
    860. 

  860. DXQueryArrayCommon(Type *t, Category *c, int *rank, int *shape, 
    861. 

  861. 		    int n, Array a, ...) 
    862. 

  862. {
    863. 

  863.     int i;
    864. 

  864.     Array alist[100];
    865. 

  865.     va_list arg;
    866. 

  866. 

  867.     ASSERT(n<100);
    868. 

  868. 

  869.     /* collect args */
    870. 

  870.     va_start(arg,a);       /* no spaces allowed - this is a weird macro */
    871. 

  871.     for (i=0; i<n; i++)
    872. 

  872. 	alist[i] = va_arg(arg, Array);
    873. 

  873.     va_end(arg);
    874. 

  874. 

  875.     /* common code with V version. */
    876. 

  876.     return QueryArrayCommon(t, c, rank, shape, n, alist, 0);
    877. 

  877. }
    878. 

  878. 

  879. Error 
    880. 

  880. DXQueryArrayCommonV(Type *t, Category *c, int *rank, int *shape, 
    881. 

  881. 		     int n, Array *alist)
    882. 

  882. {
    883. 

  883.     return QueryArrayCommon(t, c, rank, shape, n, alist, 0);
    884. 

  884. }
    885. 

  885. 

  886. 

  887. 

  888. /* sees if the array can be converted to the requested format.  
    889. 

  889.  *  should this set the error code??  (it does right now)
    890. 

  890.  */
    891. 

  891. static Error 
    892. 

  892. QueryArrayConvert(Array a, Type t, Category c, int rank, int *shape, int squeeze)
    893. 

  893. {
    894. 

  894.     int i;
    895. 

  895.     int ai, rti, rci;
    896. 

  896.     Type at;
    897. 

  897.     Category ac;
    898. 

  898.     int arank;
    899. 

  899.     int ashape[100], rshape[100];
    900. 

  900. 

  901.     if (!DXGetArrayInfo(a, NULL, &at, &ac, &arank, ashape))
    902. 

  902. 	return ERROR;
    903. 

  903. 

  904.     /* data type */
    905. 

  905.     if (at != t) {
    906. 

  906.         if ((rti = typeindex(t)) < 0)
    907. 

  907.             DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    908. 

  908.         
    909. 

  909.         if ((ai = typeindex(at)) < 0)
    910. 

  910.             DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data type");
    911. 

  911. 	
    912. 

  912.         switch (typetable[ai][rti].conversion) {
    913. 

  913.           case CONV_EQUAL:
    914. 

  914.           case CONV_ALLOWED:
    915. 

  915.             break;
    916. 

  916. 	    
    917. 

  917.           default:
    918. 

  918.             DXSetError(ERROR_DATA_INVALID, "cannot convert type %s into %s", 
    919. 

  919.                        typename(at), typename(t));
    920. 

  920.             return ERROR;
    921. 

  921.         }
    922. 

  922.     }
    923. 

  923.     
    924. 

  924.     /* data category */
    925. 

  925.     if (ac != c) {
    926. 

  926.         if ((rci = catindex(c)) < 0)
    927. 

  927.             DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    928. 

  928.         
    929. 

  929.         if ((ai = catindex(ac)) < 0) 
    930. 

  930.             DXErrorReturn(ERROR_NOT_IMPLEMENTED, "unsupported data category");
    931. 

  931.         
    932. 

  932.         switch (cattable[ai][rci].conversion) {
    933. 

  933.           case CONV_EQUAL:
    934. 

  934.           case CONV_ALLOWED:
    935. 

  935.             break;
    936. 

  936. 	    
    937. 

  937.           default:
    938. 

  938.             DXSetError(ERROR_DATA_INVALID, "cannot convert category %s into %s", 
    939. 

  939.                        catname(ac), catname(c));
    940. 

  940.             return ERROR;
    941. 

  941.         }
    942. 

  942.         
    943. 

  943.     }
    944. 

  944. 

  945.     /* get rid of 1's */
    946. 

  946.     if (squeeze) {
    947. 

  947. 	SqueezeShape(&arank, ashape);
    948. 

  948. 	for (i=0; i<rank; i++)
    949. 

  949. 	    rshape[i] = shape[i];
    950. 

  950. 	SqueezeShape(&rank, rshape);
    951. 

  951.     }
    952. 

  952.   
    953. 

  953.     if (arank != rank) {
    954. 

  954. 	if (squeeze) {
    955. 

  955. 	    DXSetError(ERROR_DATA_INVALID, "data rank does not match (%d > %d)", 
    956. 

  956. 		       arank, rank);
    957. 

  957. 	    return ERROR;
    958. 

  958. 	}
    959. 

  959. 

  960. 	return QueryArrayConvert(a, t, c, rank, shape, 1);
    961. 

  961.     }
    962. 

  962.     
    963. 

  963.     /* data rank and shape */
    964. 

  964.     for (i=0; i<rank; i++)
    965. 

  965.         if (shape[i] != rshape[i]) {
    966. 

  966. 	    if (squeeze) {
    967. 

  967. 		DXSetError(ERROR_DATA_INVALID, 
    968. 

  968. 			   "data shape does not match (%d != %d)", 
    969. 

  969. 			   shape[i], ashape[i]);
    970. 

  970. 		
    971. 

  971. 		return ERROR;
    972. 

  972. 	    }
    973. 

  973. 	    
    974. 

  974. 	    return QueryArrayConvert(a, t, c, rank, shape, 1);
    975. 

  975. 	}
    976. 

  976. 

  977.     return OK;
    978. 

  978. }
    979. 

  979. 

  980. 

  981. 

  982. Error 
    983. 

  983. DXQueryArrayConvert(Array a, Type t, Category c, int rank, ...)
    984. 

  984. {
    985. 

  985.     int i;
    986. 

  986.     int shape[100];
    987. 

  987.     va_list arg;
    988. 

  988. 

  989.     ASSERT(rank<100);
    990. 

  990. 

  991.     /* collect args */
    992. 

  992.     va_start(arg,rank);       /* no spaces allowed - this is a weird macro */
    993. 

  993.     for (i=0; i<rank; i++)
    994. 

  994. 	shape[i] = va_arg(arg, int);
    995. 

  995.     va_end(arg);
    996. 

  996. 

  997.     /* common code with V version. */
    998. 

  998.     return QueryArrayConvert(a, t, c, rank, shape, 0);
    999. 

  999. }
    1000. 

  1000. 

  1001. Error 
    1002. 

  1002. DXQueryArrayConvertV(Array a, Type t, Category c, int rank, int *shape)
    1003. 

  1003. {
    1004. 

  1004.     return QueryArrayConvert(a, t, c, rank, shape, 0);
    1005. 

  1005. }
    1006. 

  1006. 

  1007. 

  1008. 

  1009. #define MAXDIM 32
    1010. 

  1010. 

  1011. /* type check an object, and return the number if a list.
    1012. 

  1012.  */
    1013. 

  1013. Object DXQueryParameter(Object o, Type t, int dim, int *count)
    1014. 

  1014. {
    1015. 

  1015.     int nitems;
    1016. 

  1016.     Type at;
    1017. 

  1017.     Category ac;
    1018. 

  1018.     int ar, as[MAXDIM];
    1019. 

  1019. 

  1020.     /* assume the worst */
    1021. 

  1021.     if(count)
    1022. 

  1022. 	*count = 0;
    1023. 

  1023. 

  1024.     if(!o)
    1025. 

  1025. 	return NULL;
    1026. 

  1026. 

  1027.     /* slightly special case for char arrays, which might come in
    1028. 

  1028.      *  as string objects.
    1029. 

  1029.      */
    1030. 

  1030.     if ((t == TYPE_STRING) && (DXGetObjectClass(o) == CLASS_STRING)) {
    1031. 

  1031.         
    1032. 

  1032.         char *cp = DXGetString((String)o);
    1033. 

  1033.         
    1034. 

  1034.         if(!cp || dim > 1)
    1035. 

  1035.             return NULL;
    1036. 

  1036.         
    1037. 

  1037.         if(dim == 0  &&  strlen(cp) > 1)
    1038. 

  1038.             return NULL;
    1039. 

  1039.         
    1040. 

  1040.         if(count)
    1041. 

  1041.             *count = strlen(cp);
    1042. 

  1042.         
    1043. 

  1043.         return o;
    1044. 

  1044.     } 
    1045. 

  1045. 	
    1046. 

  1046. 

  1047.     /* check general characteristics first, before worrying about
    1048. 

  1048.      *  specific data types
    1049. 

  1049.      */
    1050. 

  1050.     if( DXGetObjectClass(o) != CLASS_ARRAY
    1051. 

  1051.      || !DXGetArrayInfo((Array)o, &nitems, &at, &ac, &ar, as)
    1052. 

  1052.      || ac != CATEGORY_REAL
    1053. 

  1053.      || ar > 1
    1054. 

  1054.      || nitems == 0)
    1055. 

  1055. 	return NULL;
    1056. 

  1056. 

  1057.     
    1058. 

  1058.     /* don't do these checks for strings */
    1059. 

  1059.     if (at != TYPE_STRING) {
    1060. 

  1060. 	/* if dim > 1, rank must be 1 and shape must match dim.
    1061. 

  1061. 	 * dim 0 or 1 both match rank 1 shape 1 and rank 0
    1062. 

  1062. 	 */
    1063. 

  1063. 	if(dim > 1) {
    1064. 

  1064. 	    if(ar != 1  ||  as[0] != dim)
    1065. 

  1065. 		return NULL;
    1066. 

  1066. 	} else {
    1067. 

  1067. 	    if(ar > 1 || (ar == 1  &&  as[0] != 1))
    1068. 

  1068. 		return NULL;
    1069. 

  1069. 	}
    1070. 

  1070.     }
    1071. 

  1071. 	
    1072. 

  1072.     if(count)
    1073. 

  1073. 	*count = nitems;
    1074. 

  1074. 

  1075.     /* if types match exactly, you're done */
    1076. 

  1076.     if(at == t)
    1077. 

  1077. 	return o;
    1078. 

  1078. 

  1079. 

  1080.     /* see if the types could be promoted ok.  'at' is the actual
    1081. 

  1081.      *  array type, 't' is what they want.
    1082. 

  1082.      */
    1083. 

  1083.     if (dim == 0) {
    1084. 

  1084.         if (DXQueryArrayConvert((Array)o, t, CATEGORY_REAL, 0) == OK)
    1085. 

  1085.             return o;
    1086. 

  1086.     } else {
    1087. 

  1087.         if (DXQueryArrayConvert((Array)o, t, CATEGORY_REAL, 1, dim) == OK)
    1088. 

  1088.             return o;
    1089. 

  1089.     }
    1090. 

  1090. 

  1091.     DXResetError();
    1092. 

  1092.     return NULL;
    1093. 

  1093. }
    1094. 

  1094. 

  1095. 

  1096. /* given an object, and a caller-allocated buffer, copy the input
    1097. 

  1097.  * to the buffer, converting type if necessary.
    1098. 

  1098.  */
    1099. 

  1099. Object DXExtractParameter(Object o, Type t, int dim, int count, Pointer p)
    1100. 

  1100. {
    1101. 

  1101.     Array na;
    1102. 

  1102.     char *sp;
    1103. 

  1103.     int nitems;
    1104. 

  1104.     Type at;
    1105. 

  1105.     Category ac;
    1106. 

  1106.     int ar, as[MAXDIM];
    1107. 

  1107. 

  1108.     if(!o)
    1109. 

  1109. 	return NULL;
    1110. 

  1110. 

  1111.     /* slightly special case for string arrays, which might come in
    1112. 

  1112.      *  as string objects.
    1113. 

  1113.      */
    1114. 

  1114.     if(t == TYPE_STRING  &&  DXGetObjectClass(o) == CLASS_STRING) {
    1115. 

  1115. 

  1116. 	sp = DXGetString((String)o);
    1117. 

  1117. 

  1118. 	if(!sp || dim > 1)
    1119. 

  1119. 	    return NULL;
    1120. 

  1120. 

  1121. 	if(dim == 0  &&  strlen(sp) > 1)
    1122. 

  1122. 		return NULL;
    1123. 

  1123. 

  1124. 	if(count != strlen(sp))
    1125. 

  1125. 	    return NULL;
    1126. 

  1126. 

  1127. 	if (p)
    1128. 

  1128. 	    strcpy((char *)p, sp);
    1129. 

  1129. 

  1130. 	return o;
    1131. 

  1131.     }
    1132. 

  1132. 	
    1133. 

  1133. 

  1134.     /* check general characteristics first, before worrying about
    1135. 

  1135.      *  specific data types
    1136. 

  1136.      */
    1137. 

  1137.     if( DXGetObjectClass(o) != CLASS_ARRAY
    1138. 

  1138.      || !DXGetArrayInfo((Array)o, &nitems, &at, &ac, &ar, as)
    1139. 

  1139.      || ac != CATEGORY_REAL
    1140. 

  1140.      || ar > 1
    1141. 

  1141.      || nitems == 0
    1142. 

  1142.      || nitems != count)
    1143. 

  1143. 	return NULL;
    1144. 

  1144. 

  1145. 

  1146.     /* if dim > 1, rank must be 1 and shape must match dim.
    1147. 

  1147.      * dim 0 or 1 both match rank 1 shape 1 and rank 0
    1148. 

  1148.      */
    1149. 

  1149.     if(dim > 1) {
    1150. 

  1150. 	if(ar != 1  ||  as[0] != dim)
    1151. 

  1151. 	    return NULL;
    1152. 

  1152.     } else {
    1153. 

  1153. 	if(ar > 1 || (ar == 1  &&  as[0] != 1))
    1154. 

  1154. 	    return NULL;
    1155. 

  1155.     }
    1156. 

  1156. 

  1157. 

  1158.     /* if types match exactly, just memcpy the number of bytes and return */
    1159. 

  1159.     if(at == t) {
    1160. 

  1160. 	if (p)
    1161. 

  1161. 	    memcpy(p, DXGetArrayData((Array)o), 
    1162. 

  1162. 		   nitems * DXGetItemSize((Array)o));
    1163. 

  1163. 	return o;
    1164. 

  1164.     }
    1165. 

  1165. 

  1166. 

  1167.     /* types don't match exactly, so see if they can be converted.
    1168. 

  1168.      */
    1169. 

  1169.     if (dim == 0)
    1170. 

  1170.         na = DXArrayConvert((Array)o, t, CATEGORY_REAL, 0);
    1171. 

  1171.     else
    1172. 

  1172.         na = DXArrayConvert((Array)o, t, CATEGORY_REAL, 1, dim);
    1173. 

  1173. 

  1174.     if (!na) {
    1175. 

  1175. 	DXResetError();
    1176. 

  1176.         return NULL;
    1177. 

  1177.     }
    1178. 

  1178. 

  1179.     if (p)
    1180. 

  1180. 	memcpy(p, DXGetArrayData(na), nitems * DXGetItemSize(na));
    1181. 

  1181. 

  1182.     DXDelete((Object)na);
    1183. 

  1183.     return o;
    1184. 

  1184. 

  1185. }
    1186.