Return to convert.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu

Annotation of 43BSD/ingres/source/dbu/convert.c, revision 1.1.1.1

1.1       root        1: # include      <ingres.h>
                      2: # include      <symbol.h>
                      3: # include      <sccs.h>
                      4: 
                      5: SCCSID(@(#)convert.c   8.2     1/16/85)
                      6: 
                      7: /*
                      8: **     convert  converts  numeric values of one type and length
                      9: **     to a different type and length.
                     10: **
                     11: **     The source numeric can be i1,i2,i4,f4,or f8.
                     12: **     The source number will be converted to the
                     13: **     type and length specified in the destination.
                     14: **     It also  must be one of i1,i2,i4,f4, or f8.
                     15: **
                     16: **     convert returns 0 is no overflow occured,
                     17: **       else it returns -1
                     18: */
                     19: 
                     20: convert(inp, outp, sf, slen, df, dlen)
                     21: char   *inp;   /* pointer to input */
                     22: char   *outp;  /* pointer to the output area */
                     23: int    sf;     /* format of the source number */
                     24: int    slen;   /* length of the source number */
                     25: int    df;     /* format of the dest */
                     26: int    dlen;   /* length of the dest */
                     27: {
                     28:        union anytype   number;
                     29:        register union anytype  *num;
                     30:        register int    sl;
                     31:        register int    dl;
                     32: 
                     33:        dl = dlen;
                     34:        sl = slen;
                     35:        num = &number;
                     36:        bmove(inp, num, sl);    /* copy number into buffer */
                     37: 
                     38:        if (sf != df)
                     39:        {
                     40:                /* if the source and destination formats are
                     41:                   different then the source must be converted
                     42:                   to i4 if the dest is int, otherwise to f8 */
                     43: 
                     44:                if (df == FLOAT)
                     45:                {
                     46:                        switch (sl)
                     47:                        {
                     48: 
                     49:                          case 1:
                     50:                                num->f8type = num->i1type;      /* i1 to f8 */
                     51:                                break;
                     52: 
                     53:                          case 2:
                     54:                                num->f8type = num->i2type;      /* i2 to f8 */
                     55:                                break;
                     56: 
                     57:                          case 4:
                     58:                                num->f8type = num->i4type;      /* i4 to f8 */
                     59:                        }
                     60:                sl = 8;
                     61:                }
                     62:                else
                     63:                {
                     64:                        /* check if float >  2**31 */
                     65:                        if (sl == 8)
                     66:                                num->f4type = num->f8type;      /* f8 to f4 */
                     67: 
                     68:                        if (num->f4type > MAXF4 | num->f4type < MINF4 )
                     69:                                return (-1);
                     70:                        num->i4type = num->f4type;      /* f4 to i4 */
                     71:                        sl = 4;
                     72:                }
                     73:        }
                     74: 
                     75:        /* source is now the same type as destination */
                     76:        /* convert lengths to match */
                     77: 
                     78:        if (sl != dl)
                     79:        {
                     80:                /* lengths don't match. convert. */
                     81:                if (df == FLOAT)
                     82:                {
                     83:                        if (dl == 8)
                     84:                                num->f8type = num->f4type;      /* f4 to f8 */
                     85:                        else
                     86:                                num->f4type = num->f8type;      /* f8 to f4 with rounding */
                     87:                }
                     88:                else
                     89:                {
                     90:                        switch (dl)
                     91:                        {
                     92: 
                     93:                          case 1:
                     94:                                if (sl == 2)
                     95:                                {
                     96:                                        if (num->i2type > MAXI2 | num->i2type < MINI2)
                     97:                                                return (-1);
                     98:                                        num->i1type = num->i2type;      /* i2 to i1 */
                     99:                                }
                    100:                                else
                    101:                                {
                    102:                                        if (num->i4type > MAXI2 | num->i4type < MINI2)
                    103:                                                return (-1);
                    104:                                        num->i1type = num->i4type;      /* i4 to i1 */
                    105:                                }
                    106:                                break;
                    107: 
                    108:                          case 2:
                    109:                                if (sl == 1)
                    110:                                {
                    111:                                        num->i2type = num->i1type;      /* i1 to i2 */
                    112:                                }
                    113:                                else
                    114:                                {
                    115:                                        if (num->i4type > MAXI4 | num->i4type < MINI4)
                    116:                                                return (-1);
                    117:                                        num->i2type = num->i4type;      /* i4 to i2 */
                    118:                                }
                    119:                                break;
                    120: 
                    121:                          case 4:
                    122:                                if (sl == 1)
                    123:                                        num->i4type = num->i1type;      /* i1 to i4 */
                    124:                                else
                    125:                                        num->i4type = num->i2type;      /* i2 to i4 */
                    126:                        }
                    127:                }
                    128:        }
                    129: 
                    130:        /* conversion is complete */
                    131:        /* copy the result into outp */
                    132: 
                    133:        bmove(num, outp, dl);
                    134:        return (0);
                    135: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.