printf.c

Go to the documentation of this file.

#if ever
static char sccsid[] = "@(#)printf.c    (U of Maryland) FLB 6-Jan-1987";
static char RCSid[] = "@(#)$Header: /opt/proj/minix/cvsroot/src/commands/simple/printf.c,v 1.1.1.1 2005/04/21 14:55:31 beng Exp $";
#endif

/*
 * Printf - Duplicate the C library routine of the same name, but from
 *          the shell command level.
 *
 * Fred Blonder <fred@Mimsy.umd.edu>
 *
 * To Compile:
 %      cc -s -O printf.c -o printf
 *
 * $Log: printf.c,v $
 * Revision 1.1.1.1  2005/04/21 14:55:31  beng
 * Initial import of pre-3.0.1
 *
 * Revision 1.1.1.1  2005/04/20 13:33:30  beng
 * Initial import of minix 2.0.4
 *
 * Revision 1.4  87/01/29  20:52:30  fred
 * Re-installed backslash-notation conversion for string & char arguments.
 * 
 * Revision 1.3  87/01/29  20:44:23  fred
 * Converted to portable algorithm.
 * Added Roman format for integers.
 *      29-Jan-87  FLB
 * 
 * Revision 1.2  87/01/09  19:10:57  fred
 * Fixed bug in argument-count error-checking.
 * Changed backslash escapes within strings to correspond to ANSII C
 *      draft standard.  (9-Jan-87 FLB)
 * 
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define EX_OK           0
#define EX_USAGE        1

int ctrl(char *s);

#define atoi(a)         strtoul((a), NULL, 0)

/****************************************************************************/

int main(int argc, char *argv[])
{
register char *cp, *conv_spec, **argp, **ep;
char *ctor(int x);

if (argc < 2) {
        fprintf(stderr,
                "printf: Usage: printf <format-string> [ arg1 . . . ]\n");
        exit(EX_USAGE);
        }

argp = &argv[2];        /* Point at first arg (if any) beyond format string. */
ep = &argv[argc];       /* Point beyond last arg. */

ctrl(argv[1]);  /* Change backslash notation to control chars in fmt string. */

/* Scan format string for conversion specifications, and do appropriate
   conversion on the corresponding argument. */
for (cp = argv[1]; *cp; cp++) {
register int dynamic_count;

        /* Look for next conversion spec. */
        while (*cp && *cp != '%') {
                putchar(*cp++);
                }

        if (!*cp)       /* End of format string */
                break;
                
        dynamic_count = 0;      /* Begin counting dynamic field width specs. */
        conv_spec = cp++;       /* Remember where this conversion begins. */

        for (;*cp; cp++) {      /* Scan until conversion character. */
                char conv_buf[BUFSIZ];  /* Save conversion string here. */
                register int conv_len;  /* Length of ``conv_buf''. */

                switch (*cp) {  /* Field-width spec.: Keep scanning. */
                        case '.': case '0': case '1': case '2': case '3':
                        case '4': case '5': case '6': case '7': case '8':
                        case '9':
                                continue;

                        case '*':       /* Dynamic field-width spec */
                                dynamic_count++;
                                continue;

                        case 's':       /* String */
                                if (&argp[dynamic_count] >= ep) {
                                        fprintf(stderr,
                                        "printf: Not enough args for format.\n"
                                                );
                                        exit(EX_USAGE);
                                        }

                                (void) strncpy(conv_buf, conv_spec,
                                        conv_len = cp - conv_spec + 1);
                                conv_buf[conv_len] = '\0';

                                switch (dynamic_count) {
                                        case 0:
                                                ctrl(*argp);
                                                printf(conv_buf, *argp++);
                                                break;

                                        case 1:
                                                {
                                                register int a1;

                                                a1 = atoi(*argp++);
                                                ctrl(*argp);
                                                printf(conv_buf, a1, *argp++);
                                                }
                                                break;

                                        case 2:
                                                {
                                                register int a1, a2;

                                                a1 = atoi(*argp++);
                                                a2 = atoi(*argp++);
                                                ctrl(*argp);
                                                printf(conv_buf, a1, a2, *argp++);
                                                }
                                                break;

                                        }
                                goto out;

                        case 'c':       /* Char */
                                if (&argp[dynamic_count] >= ep) {
                                        fprintf(stderr,
                                        "printf: Not enough args for format.\n"
                                                );
                                        exit(EX_USAGE);
                                        }

                                (void) strncpy(conv_buf, conv_spec,
                                        conv_len = cp - conv_spec + 1);
                                conv_buf[conv_len] = '\0';

                                switch (dynamic_count) {
                                        case 0:
                                                ctrl(*argp);
                                                printf(conv_buf, **argp++);
                                                break;

                                        case 1:
                                                {
                                                register int a1;

                                                a1 = atoi(*argp++);
                                                ctrl(*argp);
                                                printf(conv_buf, a1, **argp++);
                                                }
                                                break;

                                        case 2:
                                                {
                                                register int a1, a2;

                                                a1 = atoi(*argp++);
                                                a2 = atoi(*argp++);
                                                ctrl(*argp);
                                                printf(conv_buf, a1, a2, **argp++);
                                                }
                                                break;
                                        }
                                goto out;

                        case 'd':       /* Integer */
                        case 'o':
                        case 'x':
                        case 'X':
                        case 'u':
                                if (&argp[dynamic_count] >= ep) {
                                        fprintf(stderr,
                                        "printf: Not enough args for format.\n"
                                                );
                                        exit(EX_USAGE);
                                        }

                                (void) strncpy(conv_buf, conv_spec,
                                        conv_len = cp - conv_spec + 1);
                                conv_buf[conv_len] = '\0';

                                switch (dynamic_count) {
                                        case 0:
                                                printf(conv_buf, atoi(*argp++));
                                                break;

                                        case 1:
                                                {
                                                register int a1;

                                                a1 = atoi(*argp++);
                                                printf(conv_buf, a1, atoi(*argp++));
                                                }
                                                break;

                                        case 2:
                                                {
                                                register int a1, a2;

                                                a1 = atoi(*argp++);
                                                a2 = atoi(*argp++);
                                                printf(conv_buf, a1, a2, atoi(*argp++));
                                                }
                                                break;

                                        }
                                goto out;

                        case 'f':       /* Real */
                        case 'e':
                        case 'g':
                                if (&argp[dynamic_count] >= ep) {
                                        fprintf(stderr,
                                        "printf: Not enough args for format.\n"
                                                );
                                        exit(EX_USAGE);
                                        }

                                (void) strncpy(conv_buf, conv_spec,
                                        conv_len = cp - conv_spec + 1);
                                conv_buf[conv_len] = '\0';

                                switch (dynamic_count) {
                                        case 0:
                                                printf(conv_buf, atof(*argp++));
                                                break;

                                        case 1:
                                                {
                                                register int a1;

                                                a1 = atoi(*argp++);
                                                printf(conv_buf, a1, atof(*argp++));
                                                }
                                                break;

                                        case 2:
                                                {
                                                register int a1, a2;

                                                a1 = atoi(*argp++);
                                                a2 = atoi(*argp++);
                                                printf(conv_buf, a1, a2, atof(*argp++));
                                                }
                                                break;

                                        }
                                goto out;

                        case 'r':       /* Roman (Well, why not?) */
                                if (&argp[dynamic_count] >= ep) {
                                        fprintf(stderr,
                                        "printf: Not enough args for format.\n"
                                                );
                                        exit(EX_USAGE);
                                        }

                                (void) strncpy(conv_buf, conv_spec,
                                        conv_len = cp - conv_spec + 1);
                                conv_buf[conv_len] = '\0';
                                conv_buf[conv_len - 1] = 's';

                                switch (dynamic_count) {
                                        case 0:
                                                printf(conv_buf,
                                                        ctor(atoi(*argp++)));
                                                break;

                                        case 1:
                                                {
                                                register int a1;

                                                a1 = atoi(*argp++);
                                                printf(conv_buf, a1,
                                                        ctor(atoi(*argp++)));
                                                }
                                                break;

                                        case 2:
                                                {
                                                register int a1, a2;

                                                a1 = atoi(*argp++);
                                                a2 = atoi(*argp++);
                                                printf(conv_buf, a1, a2,
                                                        ctor(atoi(*argp++)));
                                                }
                                                break;

                                        }
                                goto out;

                        case '%':       /* Boring */
                                putchar('%');
                                break;

                        default:        /* Probably an error, but let user
                                           have his way. */
                                continue;
                        }
                }
        out: ;
        }

exit(EX_OK);
}

/****************************************************************************/

/* Convert backslash notation to control characters, in place. */

int ctrl(char *s)
{
register char *op;
static int val;

for (op = s; *s; s++)
        if (*s == '\\')
                switch (*++s) {
                        case '\0':      /* End-of-string: user goofed */
                                goto out;

                        case '\\':      /* Backslash */
                                *op++ = '\\';
                                break;

                        case 'n':       /* newline */
                                *op++ = '\n';
                                break;

                        case 't':       /* horizontal tab */
                                *op++ = '\t';
                                break;

                        case 'r':       /* carriage-return */
                                *op++ = '\r';
                                break;

                        case 'f':       /* form-feed */
                                *op++ = '\f';
                                break;

                        case 'b':       /* backspace */
                                *op++ = '\b';
                                break;

                        case 'v':       /* vertical tab */
                                *op++ = '\13';
                                break;

                        case 'a':       /* WARNING! DANGER! DANGER! DANGER! */
                                *op++ = '\7';
                                break;

                        case '0': case '1': case '2': case '3':
                        case '4': case '5': case '6': case '7':
                                {       /* octal constant */
                                register int digits;

                                val = 0;
                                (void) sscanf(s, "%3o", &val);
                                *op++ = val;
                                for (digits = 3; s[1] &&
                                        strchr("01234567", s[1])
                                        && --digits > 0;
                                                s++);
                                }
                                break;

                        case 'x':       /* hex constant */
                        case 'X':
                                s++;
                                {
                                register int digits;

                                val = 0;
                                (void) sscanf(s, "%3x", &val);
                                *op++ = val;
                                for (digits = 3; *s && s[1] &&
                                        strchr("0123456789abcdefABCDEF",
                                                                        s[1])
                                        && --digits > 0;
                                                s++);
                                }
                                break;

                        }
        else
                *op++ = *s;

out:

*op = '\0';
}

/****************************************************************************/

/* Convert integer to Roman Numerals. (Have have you survived without it?) */

struct roman {
        unsigned r_mag;
        char r_units, r_fives;
        } roman[] = {
                { 1000, 'M', '\0', },
                {  100, 'C', 'D',  },
                {   10, 'X', 'L',  },
                {    1, 'I', 'V',  },
                };

char *ctor(int x)
{
register struct roman *mp;
static char buf[BUFSIZ];
register char *cp = buf;

/* I've never actually seen a roman numeral with a minus-sign.
   Probably ought to print out some appropriate latin phrase instead. */
if (x < 0) {
        *cp++ = '-';
        x = -x;
        }

for (mp = roman; x; mp++) {
        register unsigned units;

        units = x / mp->r_mag;
        x = x % mp->r_mag;

        if (cp > &buf[BUFSIZ-2])
                return "???";

        if (units == 9 && mp > roman) { /* Do inverse notation: Eg: ``IX''. */
                *cp++ = mp->r_units;
                *cp++ = mp[-1].r_units;
                }
        else if (units == 4 && mp->r_fives) {
                /* Inverse notation for half-decades: Eg: ``IV'' */
                *cp++ = mp->r_units;
                *cp++ = mp->r_fives;
                }
        else {  /* Additive notation */
                if (units >= 5 && mp->r_fives) {
                        *cp++ = mp->r_fives;
                        units -= 5;
                        }
                while (units--) {
                        *cp++ = mp->r_units;
                        if (cp > &buf[BUFSIZ-5])
                                return "???";
                        }
                }
        }

*cp = '\0';

return buf;
}

/****************************************************************************/

---