Return to wrtfmt.c CVS log

Up to [Research Unix] / researchv10dc / libI77 / old

Annotation of researchv10dc/libI77/old/wrtfmt.c, revision 1.1

1.1     ! root        1: /*     @(#)wrtfmt.c    1.3     */
        !             2: /*     3.0 SID #       1.2     */
        !             3: #include "fio.h"
        !             4: #include "fmt.h"
        !             5: extern int cursor;
        !             6: extern char *icvt(), *ecvt();
        !             7: int hiwater;
        !             8: icilist *svic;
        !             9: char *icptr;
        !            10: mv_cur()       /* shouldn't use fseek because it insists on calling fflush */
        !            11:                /* instead we know too much about stdio */
        !            12: {
        !            13:        if(external == 0) {
        !            14:                if(cursor < 0) {
        !            15:                        if(hiwater < recpos)
        !            16:                                hiwater = recpos;
        !            17:                        recpos += cursor;
        !            18:                        icptr += cursor;
        !            19:                        cursor = 0;
        !            20:                        if(recpos < 0)
        !            21:                                err(elist->cierr, 110, "left off");
        !            22:                }
        !            23:                else if(cursor > 0) {
        !            24:                        if(recpos + cursor >= svic->icirlen)
        !            25:                                err(elist->cierr, 110, "recend");
        !            26:                        if(hiwater <= recpos)
        !            27:                                for(; cursor > 0; cursor--)
        !            28:                                        (*putn)(' ');
        !            29:                        else if(hiwater <= recpos + cursor) {
        !            30:                                cursor -= hiwater - recpos;
        !            31:                                icptr += hiwater - recpos;
        !            32:                                recpos = hiwater;
        !            33:                                for(; cursor > 0; cursor--)
        !            34:                                        (*putn)(' ');
        !            35:                        }
        !            36:                        else {
        !            37:                                icptr += cursor;
        !            38:                                recpos += cursor;
        !            39:                        }
        !            40:                        cursor = 0;
        !            41:                }
        !            42:                return(0);
        !            43:        }
        !            44:        if(cursor > 0) {
        !            45:                if(hiwater <= recpos)
        !            46:                        for(;cursor>0;cursor--) (*putn)(' ');
        !            47:                else if(hiwater <= recpos + cursor) {
        !            48:                        if(cf->_ptr + hiwater - recpos < _bufend(cf))
        !            49:                                cf->_ptr += hiwater - recpos;
        !            50:                        else
        !            51:                                (void) fseek(cf, (long) (hiwater - recpos), 1);
        !            52:                        cursor -= hiwater - recpos;
        !            53:                        recpos = hiwater;
        !            54:                        for(; cursor > 0; cursor--)
        !            55:                                (*putn)(' ');
        !            56:                }
        !            57:                else {
        !            58:                        if(cf->_ptr + cursor < _bufend(cf))
        !            59:                                cf->_ptr += cursor;
        !            60:                        else
        !            61:                                (void) fseek(cf, (long)cursor, 1);
        !            62:                        recpos += cursor;
        !            63:                }
        !            64:        }
        !            65:        if(cursor<0)
        !            66:        {
        !            67:                if(cursor+recpos<0) err(elist->cierr,110,"left off");
        !            68:                if(cf->_ptr + cursor >= cf->_base)
        !            69:                        cf->_ptr += cursor;
        !            70:                else if(curunit->useek) (void) fseek(cf,(long)cursor,1);
        !            71:                else err(elist->cierr,106,"fmt");
        !            72:                if(hiwater < recpos)
        !            73:                        hiwater = recpos;
        !            74:                recpos += cursor;
        !            75:                cursor=0;
        !            76:        }
        !            77:        return(0);
        !            78: }
        !            79: w_ed(p,ptr,len) char *ptr; struct syl *p; ftnlen len;
        !            80: {
        !            81:        if(cursor && mv_cur()) return(mv_cur());
        !            82:        switch(p->op)
        !            83:        {
        !            84:        default:
        !            85:                fprintf(stderr,"w_ed, unexpected code: %d\n%s\n",
        !            86:                        p->op,fmtbuf);
        !            87:                abort();
        !            88:        case I: return(wrt_I((uint *)ptr,p->p1,len, 10));
        !            89:        case IM:
        !            90:                return(wrt_IM((uint *)ptr,p->p1,p->p2,len));
        !            91:        case O: return(wrt_I((uint *)ptr, p->p1, len, 8));
        !            92:        case L: return(wrt_L((uint *)ptr,p->p1, len));
        !            93:        case A: return(wrt_A(ptr,len));
        !            94:        case AW:
        !            95:                return(wrt_AW(ptr,p->p1,len));
        !            96:        case D:
        !            97:        case E:
        !            98:        case EE:
        !            99:                return(wrt_E((ufloat *)ptr,p->p1,p->p2,p->p3,len));
        !           100:        case G:
        !           101:        case GE:
        !           102:                return(wrt_G((ufloat *)ptr,p->p1,p->p2,p->p3,len));
        !           103:        case F: return(wrt_F((ufloat *)ptr,p->p1,p->p2,len));
        !           104:        }
        !           105: }
        !           106: w_ned(p) struct syl *p;
        !           107: {
        !           108:        switch(p->op)
        !           109:        {
        !           110:        default: fprintf(stderr,"w_ned, unexpected code: %d\n%s\n",
        !           111:                        p->op,fmtbuf);
        !           112:                abort();
        !           113:        case SLASH:
        !           114:                return((*donewrec)());
        !           115:        case T: cursor = p->p1-recpos - 1;
        !           116:                return(1);
        !           117:        case TL: cursor -= p->p1;
        !           118:                if(cursor < -recpos)    /* TL1000, 1X */
        !           119:                        cursor = -recpos;
        !           120:                return(1);
        !           121:        case TR:
        !           122:        case X:
        !           123:                cursor += p->p1;
        !           124:                return(1);
        !           125:        case APOS:
        !           126:                return(wrt_AP(p->p1));
        !           127:        case H:
        !           128:                return(wrt_H(p->p1,p->p2));
        !           129:        }
        !           130: }
        !           131: wrt_I(n,w,len, base) uint *n; ftnlen len; register int base;
        !           132: {      int ndigit,sign,spare,i;
        !           133:        long x;
        !           134:        char *ans;
        !           135:        if(len==sizeof(short)) x=n->is;
        !           136:        else if(len == sizeof(char)) x = n->ic;
        !           137:        else x=n->il;
        !           138:        ans=icvt(x,&ndigit,&sign, base);
        !           139:        spare=w-ndigit;
        !           140:        if(sign || cplus) spare--;
        !           141:        if(spare<0)
        !           142:                for(i=0;i<w;i++) (*putn)('*');
        !           143:        else
        !           144:        {       for(i=0;i<spare;i++) (*putn)(' ');
        !           145:                if(sign) (*putn)('-');
        !           146:                else if(cplus) (*putn)('+');
        !           147:                for(i=0;i<ndigit;i++) (*putn)(*ans++);
        !           148:        }
        !           149:        return(0);
        !           150: }
        !           151: wrt_IM(n,w,m,len) uint *n; ftnlen len;
        !           152: {      int ndigit,sign,spare,i,xsign;
        !           153:        long x;
        !           154:        char *ans;
        !           155:        if(sizeof(short)==len) x=n->is;
        !           156:        else if(len == sizeof(char)) x = n->ic;
        !           157:        else x=n->il;
        !           158:        ans=icvt(x,&ndigit,&sign, 10);
        !           159:        if(sign || cplus) xsign=1;
        !           160:        else xsign=0;
        !           161:        if(ndigit+xsign>w || m+xsign>w)
        !           162:        {       for(i=0;i<w;i++) (*putn)('*');
        !           163:                return(0);
        !           164:        }
        !           165:        if(x==0 && m==0)
        !           166:        {       for(i=0;i<w;i++) (*putn)(' ');
        !           167:                return(0);
        !           168:        }
        !           169:        if(ndigit>=m)
        !           170:                spare=w-ndigit-xsign;
        !           171:        else
        !           172:                spare=w-m-xsign;
        !           173:        for(i=0;i<spare;i++) (*putn)(' ');
        !           174:        if(sign) (*putn)('-');
        !           175:        else if(cplus) (*putn)('+');
        !           176:        for(i=0;i<m-ndigit;i++) (*putn)('0');
        !           177:        for(i=0;i<ndigit;i++) (*putn)(*ans++);
        !           178:        return(0);
        !           179: }
        !           180: wrt_AP(n)
        !           181: {      char *s,quote;
        !           182:        if(cursor && mv_cur()) return(mv_cur());
        !           183:        s=(char *)n;
        !           184:        quote = *s++;
        !           185:        for(;*s;s++)
        !           186:        {       if(*s!=quote) (*putn)(*s);
        !           187:                else if(*++s==quote) (*putn)(*s);
        !           188:                else return(1);
        !           189:        }
        !           190:        return(1);
        !           191: }
        !           192: wrt_H(a,b)
        !           193: {      char *s=(char *)b;
        !           194:        if(cursor && mv_cur()) return(mv_cur());
        !           195:        while(a--) (*putn)(*s++);
        !           196:        return(1);
        !           197: }
        !           198: wrt_L(n,len, sz) uint *n; ftnlen sz;
        !           199: {      int i;
        !           200:        long x;
        !           201:        if(sizeof(short)==sz) x=n->is;
        !           202:        else if(sz == sizeof(char)) x = n->ic;
        !           203:        else x=n->il;
        !           204:        for(i=0;i<len-1;i++)
        !           205:                (*putn)(' ');
        !           206:        if(x) (*putn)('t');
        !           207:        else (*putn)('f');
        !           208:        return(0);
        !           209: }
        !           210: wrt_A(p,len) char *p; ftnlen len;
        !           211: {
        !           212:        while(len-- > 0) (*putn)(*p++);
        !           213:        return(0);
        !           214: }
        !           215: wrt_AW(p,w,len) char * p; ftnlen len;
        !           216: {
        !           217:        while(w>len)
        !           218:        {       w--;
        !           219:                (*putn)(' ');
        !           220:        }
        !           221:        while(w-- > 0)
        !           222:                (*putn)(*p++);
        !           223:        return(0);
        !           224: }
        !           225: wrt_E(p,w,d,e,len) ufloat *p; ftnlen len;
        !           226: {      char *s;
        !           227:        int dp,sign,i, delta;
        !           228:        char *ecvt();
        !           229:        double dd;
        !           230:        if(e == 0)
        !           231:                e = 2;
        !           232:        if(scale) {
        !           233:                if(scale >= d + 2 || scale <= -d)
        !           234:                        goto nogood;
        !           235:                if(scale > 0)
        !           236:                        d++;
        !           237:        }
        !           238:        if (len == sizeof(float))
        !           239:                dd = p->pf;
        !           240:        else
        !           241:                dd = p->pd;
        !           242:        s=ecvt( dd ,d,&dp,&sign);
        !           243:        delta = 1 /* for the . */ + 2 /* for the E+ */ + (sign || cplus);
        !           244:        if(w < d + e + delta) {
        !           245: nogood:
        !           246:                for(i=0;i<w;i++) (*putn)('*');
        !           247:                return(0);
        !           248:        }
        !           249:        if(p->pf != 0) dp -= scale;
        !           250:        else    dp = 0;
        !           251:        switch(e) {     /* grumph */
        !           252:        case 1:
        !           253:                if(dp <= -10 || dp >= 10)
        !           254:                        goto nogood;
        !           255:                break;
        !           256:        case 2:
        !           257:                if(dp <= -100 || dp >= 100)
        !           258:                        goto nogood;
        !           259:                break;
        !           260:        case 3:
        !           261:                if(dp <= -1000 || dp >= 1000)
        !           262:                        goto nogood;
        !           263:                break;
        !           264:        default:
        !           265:                /* probably ok */
        !           266:                break;
        !           267:        }
        !           268:        for(i=0;i<w-(delta+d+e);i++) (*putn)(' ');
        !           269:        if(sign) (*putn)('-');
        !           270:        else if(cplus) (*putn)('+');
        !           271:        if(scale<0)
        !           272:        {
        !           273:                (*putn)('.');
        !           274:                for(i=0;i<-scale;i++)
        !           275:                        (*putn)('0');
        !           276:                for(i=0;i<d+scale;i++)
        !           277:                        (*putn)(*s++);
        !           278:        }
        !           279:        else if(scale>0 && scale<d+2)
        !           280:        {       for(i=0;i<scale;i++)
        !           281:                        (*putn)(*s++);
        !           282:                (*putn)('.');
        !           283:                for(i=0;i<d-scale;i++)
        !           284:                        (*putn)(*s++);
        !           285:        }
        !           286:        else
        !           287:        {       (*putn)('.');
        !           288:                for(i=0;i<d;i++) (*putn)(*s++);
        !           289:        }
        !           290:        if(dp < 100 && dp > -100) (*putn)('e');
        !           291:        if(dp<0)
        !           292:        {       (*putn)('-');
        !           293:                dp = -dp;
        !           294:        }
        !           295:        else    (*putn)('+');
        !           296:        for(; e >= 4; e--)
        !           297:                (*putn)('0');
        !           298:        if(e>=3 || dp >= 100)
        !           299:        {       (*putn)(dp/100 + '0');
        !           300:                dp = dp % 100;
        !           301:        }
        !           302:        if(e!=1) (*putn)(dp/10+'0');
        !           303:        (*putn)(dp%10+'0');
        !           304:        return(0);
        !           305: }
        !           306: wrt_G(p,w,d,e,len) ufloat *p; ftnlen len;
        !           307: {      double up = 1,x;
        !           308:        int i,oldscale=scale,n,j;
        !           309:        x= len==sizeof(float)?p->pf:p->pd;
        !           310:        if(x < 0 ) x = -x;
        !           311:        if(x<.1) return(wrt_E(p,w,d,e,len));
        !           312:        for(i=0;i<=d;i++,up*=10)
        !           313:        {       if(x>=up) continue;
        !           314:                scale=0;
        !           315:                if(e==0) n=4;
        !           316:                else    n=e+2;
        !           317:                i=wrt_F(p,w-n,d-i,len);
        !           318:                for(j=0;j<n;j++) (*putn)(' ');
        !           319:                scale=oldscale;
        !           320:                return(i);
        !           321:        }
        !           322:        return(wrt_E((ufloat *)p,w,d,e,len));
        !           323: }
        !           324: wrt_F(p,w,d,len) ufloat *p; ftnlen len;
        !           325: {      int i,delta,dp,sign,n;
        !           326:        double x;
        !           327:        char *s,*fcvt();
        !           328:        x= (len==sizeof(float)?p->pf:p->pd);
        !           329:        if(scale)
        !           330:        {       if(scale>0)
        !           331:                        for(i=0;i<scale;i++) x*=10;
        !           332:                else    for(i=0;i<-scale;i++) x/=10;
        !           333:        }
        !           334:        s=fcvt(x,d,&dp,&sign);
        !           335:        if(-dp>=d) sign=0;
        !           336:        if(sign || cplus) delta=2;
        !           337:        else delta=1;
        !           338:        n= w - (d+delta+(dp>0?dp:0));
        !           339:        if(n<0)
        !           340:        {
        !           341:                for(i=0;i<w;i++) PUT('*');
        !           342:                return(0);
        !           343:        }
        !           344:        for(i=0;i<n;i++) PUT(' ');
        !           345:        if(sign) PUT('-');
        !           346:        else if(cplus) PUT('+');
        !           347:        for(i=0;i<dp;i++) PUT(*s++);
        !           348:        PUT('.');
        !           349:        for(i=0;i< -dp && i<d;i++) PUT('0');
        !           350:        for(;i<d;i++)
        !           351:        {       if(*s) PUT(*s++);
        !           352:                else PUT('0');
        !           353:        }
        !           354:        return(0);
        !           355: }

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