Annotation of 41BSD/lib/libI77uc/lwrite.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * list directed write
                      3:  */
                      4: 
                      5: #include "fio.h"
                      6: #include "lio.h"
                      7: 
                      8: int l_write(), t_putc();
                      9: 
                     10: s_wsle(a) cilist *a;
                     11: {
                     12:        int n;
                     13:        reading = NO;
                     14:        if(n=c_le(a,WRITE)) return(n);
                     15:        putn = t_putc;
                     16:        lioproc = l_write;
                     17:        line_len = LINE;
                     18:        curunit->uend = NO;
                     19:        leof = NO;
                     20:        if(!curunit->uwrt) nowwriting(curunit);
                     21:        return(OK);
                     22: }
                     23: 
                     24: t_putc(c) char c;
                     25: {
                     26:        if(c=='\n') recpos=0;
                     27:        else recpos++;
                     28:        putc(c,cf);
                     29:        return(OK);
                     30: }
                     31: 
                     32: e_wsle()
                     33: {      int n;
                     34:        PUT('\n')
                     35:        return(OK);
                     36: }
                     37: 
                     38: l_write(number,ptr,len,type) ftnint *number,type; flex *ptr; ftnlen len;
                     39: {
                     40:        int i,n;
                     41:        ftnint x;
                     42:        float y,z;
                     43:        double yd,zd;
                     44:        float *xx;
                     45:        double *yy;
                     46:        for(i=0;i< *number; i++)
                     47:        {
                     48:                switch((int)type)
                     49:                {
                     50:                case TYSHORT:
                     51:                        x=ptr->flshort;
                     52:                        goto xint;
                     53:                case TYLONG:
                     54:                        x=ptr->flint;
                     55:        xint:           ERR(lwrt_I(x));
                     56:                        break;
                     57:                case TYREAL:
                     58:                        ERR(lwrt_F(ptr->flreal));
                     59:                        break;
                     60:                case TYDREAL:
                     61:                        ERR(lwrt_D(ptr->fldouble));
                     62:                        break;
                     63:                case TYCOMPLEX:
                     64:                        xx= &(ptr->flreal);
                     65:                        y = *xx++;
                     66:                        z = *xx;
                     67:                        ERR(lwrt_C(y,z));
                     68:                        break;
                     69:                case TYDCOMPLEX:
                     70:                        yy = &(ptr->fldouble);
                     71:                        yd= *yy++;
                     72:                        zd = *yy;
                     73:                        ERR(lwrt_DC(yd,zd));
                     74:                        break;
                     75:                case TYLOGICAL:
                     76:                        ERR(lwrt_L(ptr->flint));
                     77:                        break;
                     78:                case TYCHAR:
                     79:                        ERR(lwrt_A((char *)ptr,len));
                     80:                        break;
                     81:                default:
                     82:                        fatal(119,"unknown type in lwrite");
                     83:                }
                     84:                ptr = (char *)ptr + len;
                     85:        }
                     86:        return(OK);
                     87: }
                     88: 
                     89: lwrt_I(in) ftnint in;
                     90: {      int n;
                     91:        char buf[16],*p;
                     92:        sprintf(buf,"  %ld",(long)in);
                     93:        if(n=chk_len(LINTW)) return(n);
                     94:        for(p=buf;*p;) PUT(*p++)
                     95:        return(OK);
                     96: }
                     97: 
                     98: lwrt_L(ln) ftnint ln;
                     99: {      int n;
                    100:        if(n=chk_len(LLOGW)) return(n);
                    101:        return(wrt_L(&ln,LLOGW));
                    102: }
                    103: 
                    104: lwrt_A(p,len) char *p; ftnlen len;
                    105: {      int i,n;
                    106:        if(n=chk_len(LSTRW)) return(n);
                    107:        PUT(' ')
                    108:        PUT(' ')
                    109:        for(i=0;i<len;i++) PUT(*p++)
                    110:        return(OK);
                    111: }
                    112: 
                    113: lwrt_F(fn) float fn;
                    114: {      int d,n; float x; ufloat f;
                    115:        if(fn==0.0) return(lwrt_0());
                    116:        f.pf = fn;
                    117:        d = width(fn);
                    118:        if(n=chk_len(d)) return(n);
                    119:        if(d==LFW)
                    120:        {
                    121:                scale = 0;
                    122:                for(d=LFD,x=abs(fn);x>=1.0;x/=10.0,d--);
                    123:                return(wrt_F(&f,LFW,d,(ftnlen)sizeof(float)));
                    124:        }
                    125:        else
                    126:        {
                    127:                scale = 1;
                    128:                return(wrt_E(&f,LEW,LED-scale,LEE,(ftnlen)sizeof(float)));
                    129:        }
                    130: }
                    131: 
                    132: lwrt_D(dn) double dn;
                    133: {      int d,n; double x; ufloat f;
                    134:        if(dn==0.0) return(lwrt_0());
                    135:        f.pd = dn;
                    136:        d = dwidth(dn);
                    137:        if(n=chk_len(d)) return(n);
                    138:        if(d==LDFW)
                    139:        {
                    140:                scale = 0;
                    141:                for(d=LDFD,x=abs(dn);x>=1.0;x/=10.0,d--);
                    142:                return(wrt_F(&f,LDFW,d,(ftnlen)sizeof(double)));
                    143:        }
                    144:        else
                    145:        {
                    146:                scale = 1;
                    147:                return(wrt_E(&f,LDEW,LDED-scale,LDEE,(ftnlen)sizeof(double)));
                    148:        }
                    149: }
                    150: 
                    151: lwrt_C(a,b) float a,b;
                    152: {      int n;
                    153:        if(n=chk_len(LCW)) return(n);
                    154:        PUT(' ')
                    155:        PUT(' ')
                    156:        PUT('(')
                    157:        if(n=lwrt_F(a)) return(n);
                    158:        PUT(',')
                    159:        if(n=lwrt_F(b)) return(n);
                    160:        PUT(')')
                    161:        return(OK);
                    162: }
                    163: 
                    164: lwrt_DC(a,b) double a,b;
                    165: {      int n;
                    166:        if(n=chk_len(LDCW)) return(n);
                    167:        PUT(' ')
                    168:        PUT(' ')
                    169:        PUT('(')
                    170:        if(n=lwrt_D(a)) return(n);
                    171:        PUT(',')
                    172:        if(n=lwrt_D(b)) return(n);
                    173:        PUT(')')
                    174:        return(OK);
                    175: }
                    176: 
                    177: lwrt_0()
                    178: {      int n; char *z = "  0.";
                    179:        if(n=chk_len(4)) return(n);
                    180:        while(*z) PUT(*z++)
                    181:        return(OK);
                    182: }
                    183: 
                    184: chk_len(w)
                    185: {      int n;
                    186:        if(recpos+w > line_len) PUT('\n')
                    187:        return(OK);
                    188: }

unix.superglobalmegacorp.com

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