Annotation of 40BSD/lib/libI77/wrtfmt.c, revision 1.1

1.1     ! root        1: #include "fio.h"
        !             2: #include "fmt.h"
        !             3: extern int cursor;
        !             4: extern char *icvt(), *ecvt();
        !             5: mv_cur()
        !             6: {      /*buggy, could move off front of record*/
        !             7:        for(;cursor>0;cursor--) (*putn)(' ');
        !             8:        if(cursor<0)
        !             9:        {
        !            10:                if(cursor+recpos<0) err(elist->cierr,110,"left off");
        !            11:                if(curunit->useek) (void) fseek(cf,(long)cursor,1);
        !            12:                else err(elist->cierr,106,"fmt");
        !            13:                cursor=0;
        !            14:        }
        !            15:        return(0);
        !            16: }
        !            17: w_ed(p,ptr,len) char *ptr; struct syl *p; ftnlen len;
        !            18: {
        !            19:        if(mv_cur()) return(mv_cur());
        !            20:        switch(p->op)
        !            21:        {
        !            22:        default:
        !            23:                fprintf(stderr,"w_ed, unexpected code: %d\n%s\n",
        !            24:                        p->op,fmtbuf);
        !            25:                abort();
        !            26:        case I: return(wrt_I((uint *)ptr,p->p1,len, 10));
        !            27:        case IM:
        !            28:                return(wrt_IM((uint *)ptr,p->p1,p->p2,len));
        !            29:        case O: return(wrt_I((uint *)ptr, p->p1, len, 8));
        !            30:        case L: return(wrt_L((uint *)ptr,p->p1, len));
        !            31:        case A: return(wrt_A(ptr,len));
        !            32:        case AW:
        !            33:                return(wrt_AW(ptr,p->p1,len));
        !            34:        case D:
        !            35:        case E:
        !            36:        case EE:
        !            37:                return(wrt_E((ufloat *)ptr,p->p1,p->p2,p->p3,len));
        !            38:        case G:
        !            39:        case GE:
        !            40:                return(wrt_G((ufloat *)ptr,p->p1,p->p2,p->p3,len));
        !            41:        case F: return(wrt_F((ufloat *)ptr,p->p1,p->p2,len));
        !            42:        }
        !            43: }
        !            44: w_ned(p) struct syl *p;
        !            45: {
        !            46:        switch(p->op)
        !            47:        {
        !            48:        default: fprintf(stderr,"w_ned, unexpected code: %d\n%s\n",
        !            49:                        p->op,fmtbuf);
        !            50:                abort();
        !            51:        case SLASH:
        !            52:                return((*donewrec)());
        !            53:        case T: cursor = p->p1-recpos - 1;
        !            54:                return(1);
        !            55:        case TL: cursor -= p->p1;
        !            56:                return(1);
        !            57:        case TR:
        !            58:        case X:
        !            59:                cursor += p->p1;
        !            60:                return(1);
        !            61:        case APOS:
        !            62:                return(wrt_AP(p->p1));
        !            63:        case H:
        !            64:                return(wrt_H(p->p1,p->p2));
        !            65:        }
        !            66: }
        !            67: wrt_I(n,w,len, base) uint *n; ftnlen len; register int base;
        !            68: {      int ndigit,sign,spare,i;
        !            69:        long x;
        !            70:        char *ans;
        !            71:        if(len==sizeof(short)) x=n->is;
        !            72:        else if(len == sizeof(char)) x = n->ic;
        !            73:        else x=n->il;
        !            74:        ans=icvt(x,&ndigit,&sign, base);
        !            75:        spare=w-ndigit;
        !            76:        if(sign || cplus) spare--;
        !            77:        if(spare<0)
        !            78:                for(i=0;i<w;i++) (*putn)('*');
        !            79:        else
        !            80:        {       for(i=0;i<spare;i++) (*putn)(' ');
        !            81:                if(sign) (*putn)('-');
        !            82:                else if(cplus) (*putn)('+');
        !            83:                for(i=0;i<ndigit;i++) (*putn)(*ans++);
        !            84:        }
        !            85:        return(0);
        !            86: }
        !            87: wrt_IM(n,w,m,len) uint *n; ftnlen len;
        !            88: {      int ndigit,sign,spare,i,xsign;
        !            89:        long x;
        !            90:        char *ans;
        !            91:        if(sizeof(short)==len) x=n->is;
        !            92:        else if(len == sizeof(char)) x = n->ic;
        !            93:        else x=n->il;
        !            94:        ans=icvt(x,&ndigit,&sign, 10);
        !            95:        if(sign || cplus) xsign=1;
        !            96:        else xsign=0;
        !            97:        if(ndigit+xsign>w || m+xsign>w)
        !            98:        {       for(i=0;i<w;i++) (*putn)('*');
        !            99:                return(0);
        !           100:        }
        !           101:        if(x==0 && m==0)
        !           102:        {       for(i=0;i<w;i++) (*putn)(' ');
        !           103:                return(0);
        !           104:        }
        !           105:        if(ndigit>=m)
        !           106:                spare=w-ndigit-xsign;
        !           107:        else
        !           108:                spare=w-m-xsign;
        !           109:        for(i=0;i<spare;i++) (*putn)(' ');
        !           110:        if(sign) (*putn)('-');
        !           111:        else if(cplus) (*putn)('+');
        !           112:        for(i=0;i<m-ndigit;i++) (*putn)('0');
        !           113:        for(i=0;i<ndigit;i++) (*putn)(*ans++);
        !           114:        return(0);
        !           115: }
        !           116: wrt_AP(n)
        !           117: {      char *s,quote;
        !           118:        if(mv_cur()) return(mv_cur());
        !           119:        s=(char *)n;
        !           120:        quote = *s++;
        !           121:        for(;*s;s++)
        !           122:        {       if(*s!=quote) (*putn)(*s);
        !           123:                else if(*++s==quote) (*putn)(*s);
        !           124:                else return(1);
        !           125:        }
        !           126:        return(1);
        !           127: }
        !           128: wrt_H(a,b)
        !           129: {      char *s=(char *)b;
        !           130:        if(mv_cur()) return(mv_cur());
        !           131:        while(a--) (*putn)(*s++);
        !           132:        return(1);
        !           133: }
        !           134: wrt_L(n,len, sz) uint *n; ftnlen sz;
        !           135: {      int i;
        !           136:        long x;
        !           137:        if(sizeof(short)==sz) x=n->is;
        !           138:        else if(sz == sizeof(char)) x = n->ic;
        !           139:        else x=n->il;
        !           140:        for(i=0;i<len-1;i++)
        !           141:                (*putn)(' ');
        !           142:        if(x) (*putn)('t');
        !           143:        else (*putn)('f');
        !           144:        return(0);
        !           145: }
        !           146: wrt_A(p,len) char *p; ftnlen len;
        !           147: {
        !           148:        while(len-- > 0) (*putn)(*p++);
        !           149:        return(0);
        !           150: }
        !           151: wrt_AW(p,w,len) char * p; ftnlen len;
        !           152: {
        !           153:        while(w>len)
        !           154:        {       w--;
        !           155:                (*putn)(' ');
        !           156:        }
        !           157:        while(w-- > 0)
        !           158:                (*putn)(*p++);
        !           159:        return(0);
        !           160: }
        !           161: wrt_E(p,w,d,e,len) ufloat *p; ftnlen len;
        !           162: {      char *s;
        !           163:        int dp,sign,i,delta;
        !           164:        char *ecvt();
        !           165:        if(scale>0) d++;
        !           166:        s=ecvt( (len==sizeof(float)?p->pf:p->pd) ,d,&dp,&sign);
        !           167:        if(sign || cplus) delta=6;
        !           168:        else delta=5;
        !           169:        if(w<delta+d)
        !           170:        {       for(i=0;i<w;i++) (*putn)('*');
        !           171:                return(0);
        !           172:        }
        !           173:        for(i=0;i<w-(delta+d);i++) (*putn)(' ');
        !           174:        if(sign) (*putn)('-');
        !           175:        else if(cplus) (*putn)('+');
        !           176:        if(scale<0 && scale > -d)
        !           177:        {
        !           178:                (*putn)('.');
        !           179:                for(i=0;i<-scale;i++)
        !           180:                        (*putn)('0');
        !           181:                for(i=0;i<d+scale;i++)
        !           182:                        (*putn)(*s++);
        !           183:        }
        !           184:        else if(scale>0 && scale<d+2)
        !           185:        {       for(i=0;i<scale;i++)
        !           186:                        (*putn)(*s++);
        !           187:                (*putn)('.');
        !           188:                for(i=0;i<d-scale;i++)
        !           189:                        (*putn)(*s++);
        !           190:        }
        !           191:        else
        !           192:        {       (*putn)('.');
        !           193:                for(i=0;i<d;i++) (*putn)(*s++);
        !           194:        }
        !           195:        if(p->pf != 0) dp -= scale;
        !           196:        else    dp = 0;
        !           197:        if(dp < 100 && dp > -100) (*putn)('e');
        !           198:        if(dp<0)
        !           199:        {       (*putn)('-');
        !           200:                dp = -dp;
        !           201:        }
        !           202:        else    (*putn)('+');
        !           203:        if(e>=3 || dp >= 100)
        !           204:        {       (*putn)(dp/100 + '0');
        !           205:                dp = dp % 100;
        !           206:        }
        !           207:        if(e!=1) (*putn)(dp/10+'0');
        !           208:        (*putn)(dp%10+'0');
        !           209:        return(0);
        !           210: }
        !           211: wrt_G(p,w,d,e,len) ufloat *p; ftnlen len;
        !           212: {      double up = 1,x;
        !           213:        int i,oldscale=scale,n,j;
        !           214:        x= len==sizeof(float)?p->pf:p->pd;
        !           215:        if(x < 0 ) x = -x;
        !           216:        if(x<.1) return(wrt_E((ufloat *)p,w,d,e,len));
        !           217:        for(i=0;i<=d;i++,up*=10)
        !           218:        {       if(x>up) continue;
        !           219:                scale=0;
        !           220:                if(e==0) n=4;
        !           221:                else    n=e+2;
        !           222:                i=wrt_F(p,w-n,d-i,len);
        !           223:                for(j=0;j<n;j++) (*putn)(' ');
        !           224:                scale=oldscale;
        !           225:                return(i);
        !           226:        }
        !           227:        return(wrt_E((ufloat *)p,w,d,e,len));
        !           228: }
        !           229: wrt_F(p,w,d,len) ufloat *p; ftnlen len;
        !           230: {      int i,delta,dp,sign,n;
        !           231:        double x;
        !           232:        char *s,*fcvt();
        !           233:        x= (len==sizeof(float)?p->pf:p->pd);
        !           234:        if(scale)
        !           235:        {       if(scale>0)
        !           236:                        for(i=0;i<scale;i++) x*=10;
        !           237:                else    for(i=0;i<-scale;i++) x/=10;
        !           238:        }
        !           239:        s=fcvt(x,d,&dp,&sign);
        !           240:        if(-dp>=d) sign=0;
        !           241:        if(sign || cplus) delta=2;
        !           242:        else delta=1;
        !           243:        n= w - (d+delta+(dp>0?dp:0));
        !           244:        if(n<0)
        !           245:        {
        !           246:                for(i=0;i<w;i++) PUT('*');
        !           247:                return(0);
        !           248:        }
        !           249:        for(i=0;i<n;i++) PUT(' ');
        !           250:        if(sign) PUT('-');
        !           251:        else if(cplus) PUT('+');
        !           252:        for(i=0;i<dp;i++) PUT(*s++);
        !           253:        PUT('.');
        !           254:        for(i=0;i< -dp && i<d;i++) PUT('0');
        !           255:        for(;i<d;i++)
        !           256:        {       if(*s) PUT(*s++);
        !           257:                else PUT('0');
        !           258:        }
        !           259:        return(0);
        !           260: }

unix.superglobalmegacorp.com

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