Return to cvstr.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / icon / rt

Annotation of 43BSD/contrib/icon/rt/cvstr.c, revision 1.1.1.1

1.1       root        1: #include "../h/rt.h"
                      2: 
                      3: /*
                      4:  * cvstr(d,s) - convert d (in place) into a string, using s as buffer
                      5:  *  if necessary.  cvstr returns 0 if the conversion fails, 1 if d
                      6:  *  wasn't a string but was converted into one, and 2 if d was already
                      7:  *  a string.  When a string conversion takes place, sbuf gets the
                      8:  *  resulting string.
                      9:  */
                     10: 
                     11: cvstr(d, sbuf)
                     12: register struct descrip *d;
                     13: char *sbuf;
                     14:    {
                     15:    
                     16:    /*
                     17:     * Dereference d if necessary.
                     18:     */
                     19:       DeRef(*d)
                     20: 
                     21:    if (QUAL(*d)) {
                     22:       /*
                     23:        * d is already a string.
                     24:        */
                     25:       if (NULLDESC(*d))
                     26:          return (NULL);
                     27:       return (2);
                     28:       }
                     29: 
                     30:    switch (TYPE(*d)) {
                     31:       /*
                     32:        * For types that can be converted into strings, call the appropriate
                     33:        *  conversion routine and return their result.  Note that the
                     34:        *  conversion routines write over d.
                     35:        */
                     36:       case T_INTEGER:
                     37:          return (itos((long)INTVAL(*d), d, sbuf));
                     38: 
                     39: #ifdef LONGS
                     40:       case T_LONGINT:
                     41:          return (itos(BLKLOC(*d)->longint.intval, d, sbuf));
                     42: #endif LONGS
                     43:       case T_REAL:
                     44:          return (rtos(BLKLOC(*d)->realblk.realval, d, sbuf));
                     45: 
                     46:       case T_CSET:
                     47:          return (cstos(BLKLOC(*d)->cset.bits, d, sbuf));
                     48: 
                     49:       default:
                     50:          /*
                     51:           * d can't be converted to a string.
                     52:           */
                     53:          return (NULL);
                     54:       }
                     55:    }
                     56: 
                     57: /*
                     58:  * itos - convert the integer num into a string using s as a buffer and
                     59:  *  making q a descriptor for the resulting string.
                     60:  */
                     61: static itos(num, q, s)
                     62: long num;
                     63: struct descrip *q;
                     64: char *s;
                     65:    {
                     66:    register char *p;
                     67:    long ival;
                     68: 
                     69:    p = s + MAXSTRING - 1;
                     70:    ival = num;
                     71: 
                     72:    *p = '\0';
                     73:    if (num >= 0L)
                     74:       do {
                     75:          *--p = ival % 10L + '0';
                     76:          ival /= 10L;
                     77:          } while (ival != 0L);
                     78:    else {
                     79:       do {
                     80:          *--p = '0' - (ival % 10L);
                     81:          ival /= 10L;
                     82:          } while (ival != 0L);
                     83:       *--p = '-';
                     84:       }
                     85:    
                     86:    STRLEN(*q) = s + MAXSTRING - 1 - p;
                     87:    STRLOC(*q) = p;
                     88:    return (1);
                     89:    }
                     90: 
                     91: /*
                     92:  * rtos - convert the real number n into a string using s as a buffer and
                     93:  *  making q a descriptor for the resulting string.
                     94:  */
                     95: rtos(n, q, s)
                     96: double n;
                     97: struct descrip *q;
                     98: char *s;
                     99:    {
                    100:    /*
                    101:     * gcvt does all the work.
                    102:     */
                    103:    gcvt(n, 8, s);
                    104:    STRLEN(*q) = strlen(s);
                    105:    STRLOC(*q) = s;
                    106:    return (1);
                    107:    }
                    108: 
                    109: /*
                    110:  * cstos - convert the cset bit array pointed at by cs into a string using
                    111:  *  s as a buffer and making q a descriptor for the resulting string.
                    112:  */
                    113: static cstos(cs, q, s)
                    114: int *cs;
                    115: struct descrip *q;
                    116: char *s;
                    117:    {
                    118:    register char *p;
                    119:    register int i;
                    120: 
                    121:    p = s;
                    122:    for (i = 0; i < CSETSIZE*INTSIZE; i++) {
                    123:       if (tstb(i, cs))
                    124:          *p++ = (char)i;
                    125:       }
                    126:    *p = '\0';
                    127: 
                    128:    STRLEN(*q) = p - s;
                    129:    STRLOC(*q) = s;
                    130:    return (1);
                    131:    }

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