Return to a2.c CVS log

Up to [CSRG BSD Unix] / 40BSD / cmd / apl

Annotation of 40BSD/cmd/apl/a2.c, revision 1.1.1.1

1.1       root        1: #include "apl.h"
                      2: 
                      3: ex_print()
                      4: {
                      5: 
                      6:        epr0();
                      7:        aputchar('\n');
                      8: }
                      9: 
                     10: ex_hprint()
                     11: {
                     12: 
                     13:        epr0();
                     14:        pop();
                     15: }
                     16: 
                     17: epr0()
                     18: {
                     19:        register struct item *p;
                     20:        register data *dp;
                     21:        data dp2;
                     22:        short int dp7;
                     23:        register i;
                     24:        int j;
                     25:        int param[4];
                     26: 
                     27:        p = fetch1();
                     28:        if(p->size == 0)
                     29:                return;
                     30:        if(p->type == DA) {
                     31:                for(i=0; i<4; i++)
                     32:                        param[i] = 0;
                     33:                dp = p->datap;
                     34:                dp2 = *(dp);
                     35:                for(i=0; i<p->size; i++)
                     36:                        epr1(*dp++, param);
                     37:                i = param[1] + param[2]; /* size if fp */
                     38:                if(i > thread.digits)
                     39:                        i += 100;
                     40:                if(param[2])
                     41:                        i++;
                     42:                if(i > param[0]+5) {
                     43:                        i = param[0] + 5; /* size if ep */
                     44:                        param[1] = param[0];
                     45:                        param[2] = -1;
                     46:                }
                     47:                if(param[3])
                     48:                        i++;    /* sign */
                     49:                i++;            /* leading space */
                     50:                param[0] = i;
                     51:                dp = p->datap;
                     52:        }
                     53:        bidx(p);
                     54:        for(i=1; i<p->size; i++) {
                     55:                if(intflg)
                     56:                        break;
                     57:                if(p->type == CH) {
                     58:                        j = getdat(p);
                     59:                        aputchar(j);
                     60:                } else
                     61:                        epr2(*dp++, param);
                     62:                for(j=p->rank-2; j>=0; j--)
                     63:                        if(i%idx.del[j] == 0)
                     64:                                aputchar('\n');
                     65:        }
                     66:        if(p->type == CH) {
                     67:                j = getdat(p);
                     68:                aputchar(j);
                     69:        } else
                     70:                epr2(*dp, param);
                     71: }
                     72: 
                     73: epr1(d, param)
                     74: data d;
                     75: int *param;
                     76: {
                     77:        double f;
                     78:        register a;
                     79:        register char *c;
                     80:        int dp, sg;
                     81: 
                     82:        f = d;
                     83:        c = ecvt(f, thread.digits, &dp, &sg);
                     84:        a = thread.digits;
                     85:        while(c[a-1]=='0' && a>1)
                     86:                a--;
                     87:        if(a > param[0])                /* sig digits */
                     88:                param[0] = a;
                     89:        a -= dp;
                     90:        if(a < 0)
                     91:                a = 0;
                     92:        if(a > param[2])                /* digits to right of dp */
                     93:                param[2] = a;
                     94:        if(dp > param[1])               /* digits to left of dp */
                     95:                param[1] = dp;
                     96:        param[3] |= sg;         /* and sign */
                     97: }
                     98: 
                     99: epr2(d, param)
                    100: int *param;
                    101: data d;
                    102: {
                    103:        register i;
                    104:        register char *c, *mc;
                    105:        double f;
                    106:        int dp, sg;
                    107: 
                    108:        if(param[0]+column > thread.width) {
                    109:                aputchar('\n');
                    110:                putto(param[0]);
                    111:        }
                    112:        f = d;
                    113:        c = ecvt(f, thread.digits, &dp, &sg);
                    114:        mc = c + thread.digits;
                    115:        aputchar(' ');
                    116:        sg = sg? '@': ' ';
                    117:        if(param[2] < 0) {
                    118:                if(param[3])
                    119:                        aputchar(sg);
                    120:                for(i=0; i<param[1]; i++) {
                    121:                        aputchar(*c++);
                    122:                        if(i == 0)
                    123:                                aputchar('.');
                    124:                }
                    125:                aputchar('e');
                    126:                dp--;
                    127:                if(dp < 0) {
                    128:                        aputchar('@');
                    129:                        dp = -dp;
                    130:                } else
                    131:                        aputchar('-');  /* an apl style plus sign */
                    132:                aputchar(dp/10 + '0');
                    133:                aputchar(dp%10 + '0');
                    134:                return;
                    135:        }
                    136:        i = dp;
                    137:        if(i < 0)
                    138:                i = 0;
                    139:        for(; i<param[1]; i++)
                    140:                aputchar(' ');
                    141:        if(param[3])
                    142:                aputchar(sg);
                    143:        for(i=0; i<dp; i++)
                    144:                if(c >= mc)
                    145:                        aputchar('0'); else
                    146:                        aputchar(*c++);
                    147:        for(i=0; i<param[2]; i++) {
                    148:                if(i == 0)
                    149:                        aputchar('.');
                    150:                if(dp < 0) {
                    151:                        aputchar('0');
                    152:                        dp++;
                    153:                } else
                    154:                if(c >= mc)
                    155:                        aputchar('0'); else
                    156:                        aputchar(*c++);
                    157:        }
                    158: }

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