1/*********************************************************************
2 *   Copyright 2009, UCAR/Unidata
3 *   See netcdf/COPYRIGHT file for copying and redistribution conditions.
4 *********************************************************************/
5/* $Id: cvt.c,v 1.2 2010/05/24 19:59:56 dmh Exp $ */
6/* $Header: /upc/share/CVS/netcdf-3/ncgen/cvt.c,v 1.2 2010/05/24 19:59:56 dmh Exp $ */
7
8#include        "includes.h"
9#include        "bytebuffer.h"
10#include "../ncdump/isnan.h"
11#include     <math.h>
12
13static char stmp[256];
14
15void
16convert1(NCConstantsrcNCConstantdst)
17{
18    Constvalue tmp;
19    unsigned char* bytes = NULL;
20    size_t bytelen;
21
22    dst->lineno = src->lineno;
23
24    /* Need to translate all possible sources to all possible sinks.*/
25    /* Rather than have a nested switch, combine the src and target into*/
26    /* a single value so we can do a single n*n-way switch*/
27
28    /* special case for src being NC_FILLVALUE*/
29    if(src->nctype == NC_FILLVALUE) {
30 if(dst->nctype != NC_FILLVALUE) {
31     nc_getfill(dst);
32 }
33 return;
34    }
35
36    /* special case handling for src being NC_ECONST*/
37    if(src->nctype == NC_ECONST) {
38 if(dst->nctype == NC_ECONST) {
39     dst->value = src->value;
40 } else {
41     Symboleconst;
42     econst = src->value.enumv;
43     convert1(&econst->typ.econst,dst);
44 }
45 return;
46    } else if(dst->nctype == NC_ECONST) {
47 /* special case for dst being NC_ECONST*/
48 semerror(lineno,"Conversion to enum not supported (yet)");
49 return;
50    }
51
52    if(src->nctype == NC_OPAQUE) {
53        bytes = makebytestring(src->value.opaquev.stringv,&bytelen);
54    }
55
56#define CASE(nc1,nc2) (nc1*256+nc2)
57 switch (CASE(src->nctype,dst->nctype)) {
58case CASE(NC_CHAR,NC_CHAR):
59    tmp.charv  = src->value.charv;
60    break;
61case CASE(NC_CHAR,NC_BYTE):
62    tmp.int8v  = (unsigned char)src->value.charv;
63    break;
64case CASE(NC_CHAR,NC_UBYTE):
65    tmp.uint8v = (unsigned char)src->value.charv;
66    break;
67case CASE(NC_CHAR,NC_USHORT):
68    tmp.uint16v = (unsigned short)src->value.charv;
69    break;
70case CASE(NC_CHAR,NC_UINT):
71    tmp.uint32v = (unsigned int)src->value.charv;
72    break;
73case CASE(NC_CHAR,NC_UINT64):
74    tmp.uint64v  = (unsigned long long)src->value.charv;
75    break;
76case CASE(NC_CHAR,NC_SHORT):
77    tmp.int16v = (short)src->value.charv;
78    break;
79case CASE(NC_CHAR,NC_INT):
80    tmp.int32v = (int)src->value.charv;
81    break;
82case CASE(NC_CHAR,NC_INT64):
83    tmp.int64v  = (long long)src->value.charv;
84    break;
85case CASE(NC_CHAR,NC_FLOAT):
86    tmp.floatv = (float)src->value.charv;
87    break;
88case CASE(NC_CHAR,NC_DOUBLE):
89    tmp.doublev = (double)src->value.charv;
90    break;
91
92case CASE(NC_BYTE,NC_CHAR):
93    tmp.charv = (char)src->value.uint8v;
94    break;
95case CASE(NC_BYTE,NC_BYTE):
96    tmp.uint8v = (unsigned char)src->value.uint8v;
97    break;
98case CASE(NC_BYTE,NC_UBYTE):
99    tmp.uint8v = (unsigned char)src->value.uint8v;
100    break;
101case CASE(NC_BYTE,NC_USHORT):
102    tmp.uint16v = (unsigned short)src->value.uint8v;
103    break;
104case CASE(NC_BYTE,NC_UINT):
105    tmp.uint32v = (unsigned int)src->value.uint8v;
106    break;
107case CASE(NC_BYTE,NC_UINT64):
108    tmp.uint64v  = (unsigned long long)src->value.uint8v;
109    break;
110case CASE(NC_BYTE,NC_SHORT):
111    tmp.int16v = (short)src->value.uint8v;
112    break;
113case CASE(NC_BYTE,NC_INT):
114    tmp.int32v = (int)src->value.uint8v;
115    break;
116case CASE(NC_BYTE,NC_INT64):
117    tmp.int64v  = (long long)src->value.uint8v;
118    break;
119case CASE(NC_BYTE,NC_FLOAT):
120    tmp.floatv = (float)src->value.uint8v;
121    break;
122case CASE(NC_BYTE,NC_DOUBLE):
123    tmp.doublev = (double)src->value.uint8v;
124    break;
125
126case CASE(NC_UBYTE,NC_CHAR):
127    tmp.charv = (char)src->value.uint8v;
128    break;
129case CASE(NC_UBYTE,NC_BYTE):
130    tmp.uint8v = (unsigned char)src->value.uint8v;
131    break;
132case CASE(NC_UBYTE,NC_UBYTE):
133    tmp.uint8v = (unsigned char)src->value.uint8v;
134    break;
135case CASE(NC_UBYTE,NC_USHORT):
136    tmp.uint16v = (unsigned short)src->value.uint8v;
137    break;
138case CASE(NC_UBYTE,NC_UINT):
139    tmp.uint32v = (unsigned int)src->value.uint8v;
140    break;
141case CASE(NC_UBYTE,NC_UINT64):
142    tmp.uint64v  = (unsigned long long)src->value.uint8v;
143    break;
144case CASE(NC_UBYTE,NC_SHORT):
145    tmp.int16v = (short)src->value.uint8v;
146    break;
147case CASE(NC_UBYTE,NC_INT):
148    tmp.int32v = (int)src->value.uint8v;
149    break;
150case CASE(NC_UBYTE,NC_INT64):
151    tmp.int64v  = (long long)src->value.uint8v;
152    break;
153case CASE(NC_UBYTE,NC_FLOAT):
154    tmp.floatv = (float)src->value.uint8v;
155    break;
156case CASE(NC_UBYTE,NC_DOUBLE):
157    tmp.doublev = (double)src->value.uint8v;
158    break;
159
160case CASE(NC_USHORT,NC_BYTE):
161    tmp.uint8v = (unsigned char)src->value.uint16v;
162    break;
163case CASE(NC_USHORT,NC_UBYTE):
164    tmp.uint8v = (unsigned char)src->value.uint16v;
165    break;
166case CASE(NC_USHORT,NC_USHORT):
167    tmp.uint16v = (unsigned short)src->value.uint16v;
168    break;
169case CASE(NC_USHORT,NC_UINT):
170    tmp.uint32v = (unsigned int)src->value.uint16v;
171    break;
172case CASE(NC_USHORT,NC_UINT64):
173    tmp.uint64v  = (unsigned long long)src->value.uint16v;
174    break;
175case CASE(NC_USHORT,NC_SHORT):
176    tmp.int16v = (short)src->value.uint16v;
177    break;
178case CASE(NC_USHORT,NC_INT):
179    tmp.int32v = (int)src->value.uint16v;
180    break;
181case CASE(NC_USHORT,NC_INT64):
182    tmp.int64v  = (long long)src->value.uint16v;
183    break;
184case CASE(NC_USHORT,NC_FLOAT):
185    tmp.floatv = (float)src->value.uint16v;
186    break;
187case CASE(NC_USHORT,NC_DOUBLE):
188    tmp.doublev = (double)src->value.uint16v;
189    break;
190
191case CASE(NC_UINT,NC_BYTE):
192    tmp.uint8v = (unsigned char)src->value.uint32v;
193    break;
194case CASE(NC_UINT,NC_UBYTE):
195    tmp.uint8v = (unsigned char)src->value.uint32v;
196    break;
197case CASE(NC_UINT,NC_USHORT):
198    tmp.uint16v = (unsigned short)src->value.uint32v;
199    break;
200case CASE(NC_UINT,NC_UINT):
201    tmp.uint32v = (unsigned int)src->value.uint32v;
202    break;
203case CASE(NC_UINT,NC_UINT64):
204    tmp.uint64v  = (unsigned long long)src->value.uint32v;
205    break;
206case CASE(NC_UINT,NC_SHORT):
207    tmp.int16v = (short)src->value.uint32v;
208    break;
209case CASE(NC_UINT,NC_INT):
210    tmp.int32v = (int)src->value.uint32v;
211    break;
212case CASE(NC_UINT,NC_INT64):
213    tmp.int64v  = (long long)src->value.uint32v;
214    break;
215case CASE(NC_UINT,NC_FLOAT):
216    tmp.floatv = (float)src->value.uint32v;
217    break;
218case CASE(NC_UINT,NC_DOUBLE):
219    tmp.doublev = (double)src->value.uint32v;
220    break;
221
222case CASE(NC_UINT64,NC_BYTE):
223    tmp.uint8v = (unsigned char)src->value.uint64v;
224    break;
225case CASE(NC_UINT64,NC_UBYTE):
226    tmp.uint8v = (unsigned char)src->value.uint64v;
227    break;
228case CASE(NC_UINT64,NC_USHORT):
229    tmp.uint16v = (unsigned short)src->value.uint64v;
230    break;
231case CASE(NC_UINT64,NC_UINT):
232    tmp.uint32v = (unsigned int)src->value.uint64v;
233    break;
234case CASE(NC_UINT64,NC_UINT64):
235    tmp.uint64v  = (unsigned long long)src->value.uint64v;
236    break;
237case CASE(NC_UINT64,NC_SHORT):
238    tmp.int16v = (short)src->value.uint64v;
239    break;
240case CASE(NC_UINT64,NC_INT):
241    tmp.int32v = (int)src->value.uint64v;
242    break;
243case CASE(NC_UINT64,NC_INT64):
244    tmp.int64v  = (long long)src->value.uint64v;
245    break;
246case CASE(NC_UINT64,NC_FLOAT):
247    tmp.floatv = (float)src->value.uint64v;
248    break;
249case CASE(NC_UINT64,NC_DOUBLE):
250    tmp.doublev = (double)src->value.uint64v;
251    break;
252
253case CASE(NC_SHORT,NC_BYTE):
254    tmp.uint8v = (unsigned char)src->value.int16v;
255    break;
256case CASE(NC_SHORT,NC_UBYTE):
257    tmp.uint8v = (unsigned char)src->value.int16v;
258    break;
259case CASE(NC_SHORT,NC_USHORT):
260    tmp.uint16v = (unsigned short)src->value.int16v;
261    break;
262case CASE(NC_SHORT,NC_UINT):
263    tmp.uint32v = (unsigned int)src->value.int16v;
264    break;
265case CASE(NC_SHORT,NC_UINT64):
266    tmp.uint64v  = (unsigned long long)src->value.int16v;
267    break;
268case CASE(NC_SHORT,NC_SHORT):
269    tmp.int16v = (short)src->value.int16v;
270    break;
271case CASE(NC_SHORT,NC_INT):
272    tmp.int32v = (int)src->value.int16v;
273    break;
274case CASE(NC_SHORT,NC_INT64):
275    tmp.int64v  = (long long)src->value.int16v;
276    break;
277case CASE(NC_SHORT,NC_FLOAT):
278    tmp.floatv = (float)src->value.int16v;
279    break;
280case CASE(NC_SHORT,NC_DOUBLE):
281    tmp.doublev = (double)src->value.int16v;
282    break;
283
284case CASE(NC_INT,NC_BYTE):
285    tmp.uint8v = (unsigned char)src->value.int32v;
286    break;
287case CASE(NC_INT,NC_UBYTE):
288    tmp.uint8v = (unsigned char)src->value.int32v;
289    break;
290case CASE(NC_INT,NC_USHORT):
291    tmp.uint16v = (unsigned short)src->value.int32v;
292    break;
293case CASE(NC_INT,NC_UINT):
294    tmp.uint32v = (unsigned int)src->value.int32v;
295    break;
296case CASE(NC_INT,NC_UINT64):
297    tmp.uint64v  = (unsigned long long)src->value.int32v;
298    break;
299case CASE(NC_INT,NC_SHORT):
300    tmp.int16v = (short)src->value.int32v;
301    break;
302case CASE(NC_INT,NC_INT):
303    tmp.int32v = (int)src->value.int32v;
304    break;
305case CASE(NC_INT,NC_INT64):
306    tmp.int64v  = (long long)src->value.int32v;
307    break;
308case CASE(NC_INT,NC_FLOAT):
309    tmp.floatv = (float)src->value.int32v;
310    break;
311case CASE(NC_INT,NC_DOUBLE):
312    tmp.doublev = (double)src->value.int32v;
313    break;
314
315case CASE(NC_INT64,NC_BYTE):
316    tmp.uint8v = (unsigned char)src->value.int64v;
317    break;
318case CASE(NC_INT64,NC_UBYTE):
319    tmp.uint8v = (unsigned char)src->value.int64v;
320    break;
321case CASE(NC_INT64,NC_USHORT):
322    tmp.uint16v = (unsigned short)src->value.int64v;
323    break;
324case CASE(NC_INT64,NC_UINT):
325    tmp.uint32v = (unsigned int)src->value.int64v;
326    break;
327case CASE(NC_INT64,NC_UINT64):
328    tmp.uint64v  = (unsigned long long)src->value.int64v;
329    break;
330case CASE(NC_INT64,NC_SHORT):
331    tmp.int16v = (short)src->value.int64v;
332    break;
333case CASE(NC_INT64,NC_INT):
334    tmp.int32v = (int)src->value.int64v;
335    break;
336case CASE(NC_INT64,NC_INT64):
337    tmp.int64v  = (long long)src->value.int64v;
338    break;
339case CASE(NC_INT64,NC_FLOAT):
340    tmp.floatv = (float)src->value.int64v;
341    break;
342case CASE(NC_INT64,NC_DOUBLE):
343    tmp.doublev = (double)src->value.int64v;
344    break;
345
346case CASE(NC_FLOAT,NC_BYTE):
347    tmp.uint8v = (unsigned char)src->value.floatv;
348    break;
349case CASE(NC_FLOAT,NC_UBYTE):
350    tmp.uint8v = (unsigned char)src->value.floatv;
351    break;
352case CASE(NC_FLOAT,NC_USHORT):
353    tmp.uint16v = (unsigned short)src->value.floatv;
354    break;
355case CASE(NC_FLOAT,NC_UINT):
356    tmp.uint32v = (unsigned int)src->value.floatv;
357    break;
358case CASE(NC_FLOAT,NC_UINT64):
359    tmp.uint64v  = (unsigned long long)src->value.floatv;
360    break;
361case CASE(NC_FLOAT,NC_SHORT):
362    tmp.int16v = (short)src->value.floatv;
363    break;
364case CASE(NC_FLOAT,NC_INT):
365    tmp.int32v = (int)src->value.floatv;
366    break;
367case CASE(NC_FLOAT,NC_INT64):
368    tmp.int64v  = (long long)src->value.floatv;
369    break;
370case CASE(NC_FLOAT,NC_FLOAT):
371    tmp.floatv = src->value.floatv;
372    break;
373case CASE(NC_FLOAT,NC_DOUBLE):
374    tmp.doublev = (isnan(src->value.floatv)?NAN:(double)src->value.floatv);
375    break;
376case CASE(NC_DOUBLE,NC_BYTE):
377    tmp.uint8v = (unsigned char)src->value.doublev;
378    break;
379case CASE(NC_DOUBLE,NC_UBYTE):
380    tmp.uint8v = (unsigned char)src->value.doublev;
381    break;
382case CASE(NC_DOUBLE,NC_USHORT):
383    tmp.uint16v = (unsigned short)src->value.doublev;
384    break;
385case CASE(NC_DOUBLE,NC_UINT):
386    tmp.uint32v = (unsigned int)src->value.doublev;
387    break;
388case CASE(NC_DOUBLE,NC_UINT64):
389    tmp.uint64v  = (unsigned long long)src->value.doublev;
390    break;
391case CASE(NC_DOUBLE,NC_SHORT):
392    tmp.int16v = (short)src->value.doublev;
393    break;
394case CASE(NC_DOUBLE,NC_INT):
395    tmp.int32v = (int)src->value.doublev;
396    break;
397case CASE(NC_DOUBLE,NC_INT64):
398    tmp.int64v  = (long long)src->value.doublev;
399    break;
400case CASE(NC_DOUBLE,NC_FLOAT):
401    tmp.floatv = (isnan(src->value.doublev)?NANF:(float)src->value.doublev);
402    break;
403case CASE(NC_DOUBLE,NC_DOUBLE):
404    tmp.doublev = (double)src->value.doublev;
405    break;
406
407/* Conversion of a string to e.g. an integer should be what?*/
408case CASE(NC_STRING,NC_BYTE):
409    sscanf(src->value.stringv.stringv,"%hhd",&tmp.int8v); break;
410case CASE(NC_STRING,NC_UBYTE):
411    sscanf(src->value.stringv.stringv,"%hhu",&tmp.uint8v); break;
412case CASE(NC_STRING,NC_USHORT):
413    sscanf(src->value.stringv.stringv,"%hu",&tmp.uint16v); break;
414case CASE(NC_STRING,NC_UINT):
415    sscanf(src->value.stringv.stringv,"%u",&tmp.uint32v); break;
416case CASE(NC_STRING,NC_UINT64):
417    sscanf(src->value.stringv.stringv,"%llu",&tmp.uint64v); break;
418case CASE(NC_STRING,NC_SHORT):
419    sscanf(src->value.stringv.stringv,"%hd",&tmp.int16v); break;
420case CASE(NC_STRING,NC_INT):
421    sscanf(src->value.stringv.stringv,"%d",&tmp.int32v); break;
422case CASE(NC_STRING,NC_INT64):
423    sscanf(src->value.stringv.stringv,"%lld",&tmp.int64v); break;
424case CASE(NC_STRING,NC_FLOAT):
425    sscanf(src->value.stringv.stringv,"%g",&tmp.floatv); break;
426case CASE(NC_STRING,NC_DOUBLE):
427    sscanf(src->value.stringv.stringv,"%lg",&tmp.doublev); break;
428case CASE(NC_STRING,NC_CHAR):
429     tmp.charv = src->value.stringv.stringv[0];
430     break;
431case CASE(NC_STRING,NC_STRING):
432    /* Need to watch out for embedded NULs */
433    tmp.stringv.len = src->value.stringv.len;
434    tmp.stringv.stringv = (char*)malloc(src->value.stringv.len+1);
435    memcpy((void*)tmp.stringv.stringv,
436           (void*)src->value.stringv.stringv,
437           tmp.stringv.len);
438    tmp.stringv.stringv[tmp.stringv.len] = '\0';
439    break;
440
441/* What is the proper conversion for T->STRING?*/
442case CASE(NC_CHAR,NC_STRING):
443    sprintf(stmp,"%c",src->value.charv);
444    tmp.stringv.len = nulllen(stmp);
445    tmp.stringv.stringv = nulldup(stmp);
446    break;
447case CASE(NC_BYTE,NC_STRING):
448    sprintf(stmp,"%hhd",src->value.uint8v);
449    tmp.stringv.len = nulllen(stmp);
450    tmp.stringv.stringv = nulldup(stmp);
451    break;
452case CASE(NC_UBYTE,NC_STRING):
453    sprintf(stmp,"%hhu",src->value.uint8v);
454    tmp.stringv.len = nulllen(stmp);
455    tmp.stringv.stringv = nulldup(stmp);
456    break;
457case CASE(NC_USHORT,NC_STRING):
458    sprintf(stmp,"%hu",src->value.uint16v);
459    tmp.stringv.len = nulllen(stmp);
460    tmp.stringv.stringv = nulldup(stmp);
461    break;
462case CASE(NC_UINT,NC_STRING):
463    sprintf(stmp,"%u",src->value.uint32v);
464    tmp.stringv.len = nulllen(stmp);
465    tmp.stringv.stringv = nulldup(stmp);
466    break;
467case CASE(NC_UINT64,NC_STRING):
468    sprintf(stmp,"%llu",src->value.uint64v);
469    tmp.stringv.len = nulllen(stmp);
470    tmp.stringv.stringv = nulldup(stmp);
471    break;
472case CASE(NC_SHORT,NC_STRING):
473    sprintf(stmp,"%hd",src->value.int16v);
474    tmp.stringv.len = nulllen(stmp);
475    tmp.stringv.stringv = nulldup(stmp);
476    break;
477case CASE(NC_INT,NC_STRING):
478    sprintf(stmp,"%d",src->value.int32v);
479    tmp.stringv.len = nulllen(stmp);
480    tmp.stringv.stringv = nulldup(stmp);
481    break;
482case CASE(NC_INT64,NC_STRING):
483    sprintf(stmp,"%lld",src->value.int64v);
484    tmp.stringv.len = nulllen(stmp);
485    tmp.stringv.stringv = nulldup(stmp);
486    break;
487case CASE(NC_FLOAT,NC_STRING):
488    sprintf(stmp,"%.8g",src->value.floatv);
489    tmp.stringv.len = nulllen(stmp);
490    tmp.stringv.stringv = nulldup(stmp);
491    break;
492case CASE(NC_DOUBLE,NC_STRING):
493    sprintf(stmp,"%.8g",src->value.doublev);
494    tmp.stringv.len = nulllen(stmp);
495    tmp.stringv.stringv = nulldup(stmp);
496    break;
497
498case CASE(NC_OPAQUE,NC_CHAR):
499  if(bytes)
500    tmp.charv = *(char*)bytes;
501  break;
502case CASE(NC_OPAQUE,NC_BYTE):
503  if(bytes)
504    tmp.uint8v = *(unsigned char*)bytes;
505    break;
506case CASE(NC_OPAQUE,NC_UBYTE):
507  if(bytes)
508    tmp.uint8v = *(unsigned char*)bytes;
509  break;
510case CASE(NC_OPAQUE,NC_USHORT):
511  if(bytes)
512    tmp.uint16v = *(unsigned short*)bytes;
513  break;
514case CASE(NC_OPAQUE,NC_UINT):
515  if(bytes)
516    tmp.uint32v = *(unsigned int*)bytes;
517  break;
518case CASE(NC_OPAQUE,NC_UINT64):
519  if(bytes)
520    tmp.uint64v  = *(unsigned long long*)bytes;
521  break;
522case CASE(NC_OPAQUE,NC_SHORT):
523  if(bytes)
524    tmp.int16v = *(short*)bytes;
525  break;
526case CASE(NC_OPAQUE,NC_INT):
527  if(bytes)
528    tmp.int32v = *(int*)bytes;
529  break;
530case CASE(NC_OPAQUE,NC_INT64):
531  if(bytes)
532    tmp.int64v  = *(long long*)bytes;
533  break;
534case CASE(NC_OPAQUE,NC_FLOAT):
535  if(bytes)
536    tmp.floatv = *(float*)bytes;
537  break;
538case CASE(NC_OPAQUE,NC_DOUBLE):
539  if(bytes)
540    tmp.doublev = *(double*)bytes;
541  break;
542case CASE(NC_OPAQUE,NC_OPAQUE):
543    tmp.opaquev.stringv = (char*)malloc(src->value.opaquev.len+1);
544    memcpy(tmp.opaquev.stringv,src->value.opaquev.stringv,src->value.opaquev.len);
545    tmp.opaquev.len = src->value.opaquev.len;
546    tmp.opaquev.stringv[tmp.opaquev.len] = '\0';
547    break;
548case CASE(NC_NIL,NC_NIL):
549    break; /* probably will never happen */
550case CASE(NC_NIL,NC_STRING):
551    tmp.stringv.len = 0;
552    tmp.stringv.stringv = NULL;
553    break;
554
555    /* We are missing all CASE(X,NC_ECONST) cases*/
556
557    default:
558 semerror(lineno,"transform: illegal conversion: %s/%d -> %s/%d",
559 nctypename(src->nctype),src->nctype,
560 nctypename(dst->nctype),dst->nctype);
561 break;;
562    }
563
564    if(bytes != NULLefree(bytes); /* cleanup*/
565
566    /* overwrite minimum necessary parts*/
567    dst->value = tmp;
568}
569
570#ifdef IGNORE
571/* Force an Opaque or string to conform to a given length*/
572void
573setprimlength(NCConstantprim, unsigned long len)
574{
575    ASSERT(isprimplus(prim->nctype));
576    if(prim->nctype == NC_STRING) {
577        if(prim->value.stringv.len == len) {
578     /* do nothing*/
579        } else if(prim->value.stringv.len > len) { /* truncate*/
580     prim->value.stringv.stringv[len] = '\0';
581     prim->value.stringv.len = len;
582        } else {/* prim->value.stringv.len > srcov->len*/
583     char* s;
584            s = (char*)emalloc(len+1);
585     memset(s,NC_FILL_CHAR,len);
586     s[len] = '\0';
587     memcpy(s,prim->value.stringv.stringv,prim->value.stringv.len);
588     efree(prim->value.stringv.stringv);
589     prim->value.stringv.stringv = s;
590            prim->value.stringv.len = len;
591 }
592    } else if(prim->nctype == NC_OPAQUE) {
593 /* Note that expansion/contraction is in terms of whole
594           bytes = 2 nibbles */
595 ASSERT((len % 2) == 0);
596        if(prim->value.opaquev.len == len) {
597     /* do nothing*/
598        } else if(prim->value.opaquev.len > len) { /* truncate*/
599     prim->value.opaquev.stringv[len] = '\0';
600     prim->value.opaquev.len = len;
601        } else {/* prim->value.opaquev.len < len => expand*/
602     char* s;
603     s = (char*)emalloc(len+1);
604     memset(s,'0',len);
605     memcpy(s,prim->value.opaquev.stringv,prim->value.opaquev.len);
606     s[len] = '\0';
607     efree(prim->value.opaquev.stringv);
608     prim->value.opaquev.stringv=s;
609     prim->value.opaquev.len = len;
610        }
611    }
612}
613#endif
614
615Datalist*
616convertstringtochars(NCConstantstr)
617{
618    int i;
619    Datalistdl;
620    int slen;
621    char* s;
622
623    slen = str->value.stringv.len;
624    dl = builddatalist(slen);
625    s = str->value.stringv.stringv;
626    for(i=0;i<slen;i++) {
627 NCConstant con;
628 con.nctype = NC_CHAR;
629        con.lineno = str->lineno;
630        con.value.charv = s[i];
631 con.filled = 0;
632 dlappend(dl,&con);
633    }
634    return dl;
635}


HyperKWIC - Version 7.20DA executed at 11:37 on 27 Oct 2017 | Polyhedron Solutions - INTERNAL USE | COMMERCIAL (Any O/S) SN 4AKIed