Return to output.c CVS log

Up to [MW Coherent from dump] / coherent / d / bin / bc

Annotation of coherent/d/bin/bc/output.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "bc.h"
                      3: 
                      4: 
                      5: /*
                      6:  *     The int left is equal to the number of columns left on the
                      7:  *     output line.
                      8:  */
                      9: 
                     10: static int     left = LINELEN;
                     11: 
                     12: 
                     13: /*
                     14:  *     Pstring is used to print a string onto the standard output,
                     15:  *     maintaining the number of characters left on the line in
                     16:  *     left.  `field' is the minimum number of characters to be used.
                     17:  *     Padding is zeros on the left.
                     18:  */
                     19: 
                     20: pstring(str, field)
                     21: register char  *str;
                     22: int            field;
                     23: {
                     24:        register int    len;
                     25:        static char newln[] = "\\\n";
                     26: 
                     27:        if (field == 0) {
                     28:                while (*str != 0) {
                     29:                        if (*str == '\t') {
                     30:                                if (left & 7)
                     31:                                        left &= ~7;
                     32:                                else
                     33:                                        left -= 8;
                     34:                                if (left <= 0) {
                     35:                                        left = LINELEN - 8;
                     36:                                        printf(newln);
                     37:                                }
                     38:                                putchar(*str++);
                     39:                        } else {
                     40:                                putchar(*str++);
                     41:                                if (--left == 0) {
                     42:                                        left = LINELEN;
                     43:                                        printf(newln);
                     44:                                }
                     45:                        }
                     46:                }
                     47:        } else {
                     48:                len = strlen(str);
                     49:                if (field < len)
                     50:                        field = len;
                     51:                if (left < field && field <= LINELEN) {
                     52:                        printf(newln);
                     53:                        left = LINELEN;
                     54:                }
                     55:                for (field -= len; field != 0; --field) {
                     56:                        putchar('0');
                     57:                        if (--left == 0) {
                     58:                                left = LINELEN;
                     59:                                printf(newln);
                     60:                        }
                     61:                }
                     62:                for (; left < len; len -= left) {
                     63:                        printf("%.*s\\\n", left, str);
                     64:                        str += left;
                     65:                        left = LINELEN;
                     66:                }
                     67:                printf("%s", str);
                     68:                left -= len;
                     69:        }
                     70: }
                     71: 
                     72: 
                     73: /*
                     74:  *     Pnewln prints out a newline on standard output, updateing
                     75:  *     left.
                     76:  */
                     77: 
                     78: pnewln()
                     79: {
                     80:        putchar('\n');
                     81:        left = LINELEN;
                     82: }

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