URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [coremark/] [ee_printf.c] - Blame information for rev 639

Go to most recent revision | Details | Compare with Previous | View Log


/* File : barebones/ee_printf.c
        This file contains an implementation of ee_printf that only requires a method to output a char to a UART without pulling in library code.
 
This code is based on a file that contains the following:
 Copyright (C) 2002 Michael Ringgaard. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions
 are met:
 
 1. Redistributions of source code must retain the above copyright
    notice, this list of conditions and the following disclaimer.
 2. Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 3. Neither the name of the project nor the names of its contributors
    may be used to endorse or promote products derived from this software
    without specific prior written permission.
 
 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 SUCH DAMAGE.
 
*/
 
#include "coremark.h"
#include <stdarg.h>
#include "support.h"
#include "board.h"
#include "uart.h"
 
#define ZEROPAD         (1<<0)  /* Pad with zero */
#define SIGN            (1<<1)  /* Unsigned/signed long */
#define PLUS            (1<<2)  /* Show plus */
#define SPACE           (1<<3)  /* Spacer */
#define LEFT            (1<<4)  /* Left justified */
#define HEX_PREP        (1<<5)  /* 0x */
#define UPPERCASE   (1<<6)      /* 'ABCDEF' */
 
#define is_digit(c) ((c) >= '0' && (c) <= '9')
 
static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static size_t strnlen(const char *s, size_t count);
 
static size_t strnlen(const char *s, size_t count)
{
        const char *sc;
        for (sc = s; *sc != '\0' && count--; ++sc) ;
        return sc - s;
}
 
static int skip_atoi(const char **s)
{
        int i = 0;
        while (is_digit(**s))
                i = i * 10 + *((*s)++) - '0';
        return i;
}
 
static char *number(char *str, long num, int base, int size, int precision,
                    int type)
{
        char c, sign, tmp[66];
        char *dig = digits;
        int i;
 
        if (type & UPPERCASE)
                dig = upper_digits;
        if (type & LEFT)
                type &= ~ZEROPAD;
        if (base < 2 || base > 36)
                return 0;
 
        c = (type & ZEROPAD) ? '0' : ' ';
        sign = 0;
        if (type & SIGN) {
                if (num < 0) {
                        sign = '-';
                        num = -num;
                        size--;
                } else if (type & PLUS) {
                        sign = '+';
                        size--;
                } else if (type & SPACE) {
                        sign = ' ';
                        size--;
                }
        }
 
        if (type & HEX_PREP) {
                if (base == 16)
                        size -= 2;
                else if (base == 8)
                        size--;
        }
 
        i = 0;
 
        if (num == 0)
                tmp[i++] = '0';
        else {
                while (num != 0) {
                        tmp[i++] = dig[((unsigned long)num) % (unsigned)base];
                        num = ((unsigned long)num) / (unsigned)base;
                }
        }
 
        if (i > precision)
                precision = i;
        size -= precision;
        if (!(type & (ZEROPAD | LEFT)))
                while (size-- > 0)
                        *str++ = ' ';
        if (sign)
                *str++ = sign;
 
        if (type & HEX_PREP) {
                if (base == 8)
                        *str++ = '0';
                else if (base == 16) {
                        *str++ = '0';
                        *str++ = digits[33];
                }
        }
 
        if (!(type & LEFT))
                while (size-- > 0)
                        *str++ = c;
        while (i < precision--)
                *str++ = '0';
        while (i-- > 0)
                *str++ = tmp[i];
        while (size-- > 0)
                *str++ = ' ';
 
        return str;
}
 
static char *eaddr(char *str, unsigned char *addr, int size, int precision,
                   int type)
{
        char tmp[24];
        char *dig = digits;
        int i, len;
 
        if (type & UPPERCASE)
                dig = upper_digits;
        len = 0;
        for (i = 0; i < 6; i++) {
                if (i != 0)
                        tmp[len++] = ':';
                tmp[len++] = dig[addr[i] >> 4];
                tmp[len++] = dig[addr[i] & 0x0F];
        }
 
        if (!(type & LEFT))
                while (len < size--)
                        *str++ = ' ';
        for (i = 0; i < len; ++i)
                *str++ = tmp[i];
        while (len < size--)
                *str++ = ' ';
 
        return str;
}
 
static char *iaddr(char *str, unsigned char *addr, int size, int precision,
                   int type)
{
        char tmp[24];
        int i, n, len;
 
        len = 0;
        for (i = 0; i < 4; i++) {
                if (i != 0)
                        tmp[len++] = '.';
                n = addr[i];
 
                if (n == 0)
                        tmp[len++] = digits[0];
                else {
                        if (n >= 100) {
                                tmp[len++] = digits[n / 100];
                                n = n % 100;
                                tmp[len++] = digits[n / 10];
                                n = n % 10;
                        } else if (n >= 10) {
                                tmp[len++] = digits[n / 10];
                                n = n % 10;
                        }
 
                        tmp[len++] = digits[n];
                }
        }
 
        if (!(type & LEFT))
                while (len < size--)
                        *str++ = ' ';
        for (i = 0; i < len; ++i)
                *str++ = tmp[i];
        while (len < size--)
                *str++ = ' ';
 
        return str;
}
 
#ifdef HAS_FLOAT
 
char *ecvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
char *fcvtbuf(double arg, int ndigits, int *decpt, int *sign, char *buf);
static void ee_bufcpy(char *d, char *s, int count);
 
void ee_bufcpy(char *pd, char *ps, int count)
{
        char *pe = ps + count;
        while (ps != pe)
                *pd++ = *ps++;
}
 
static void parse_float(double value, char *buffer, char fmt, int precision)
{
        int decpt, sign, exp, pos;
        char *digits = NULL;
        char cvtbuf[80];
        int capexp = 0;
        int magnitude;
 
        if (fmt == 'G' || fmt == 'E') {
                capexp = 1;
                fmt += 'a' - 'A';
        }
 
        if (fmt == 'g') {
                digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);
                magnitude = decpt - 1;
                if (magnitude < -4 || magnitude > precision - 1) {
                        fmt = 'e';
                        precision -= 1;
                } else {
                        fmt = 'f';
                        precision -= decpt;
                }
        }
 
        if (fmt == 'e') {
                digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);
 
                if (sign)
                        *buffer++ = '-';
                *buffer++ = *digits;
                if (precision > 0)
                        *buffer++ = '.';
                ee_bufcpy(buffer, digits + 1, precision);
                buffer += precision;
                *buffer++ = capexp ? 'E' : 'e';
 
                if (decpt == 0) {
                        if (value == 0.0)
                                exp = 0;
                        else
                                exp = -1;
                } else
                        exp = decpt - 1;
 
                if (exp < 0) {
                        *buffer++ = '-';
                        exp = -exp;
                } else
                        *buffer++ = '+';
 
                buffer[2] = (exp % 10) + '0';
                exp = exp / 10;
                buffer[1] = (exp % 10) + '0';
                exp = exp / 10;
                buffer[0] = (exp % 10) + '0';
                buffer += 3;
        } else if (fmt == 'f') {
                digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);
                if (sign)
                        *buffer++ = '-';
                if (*digits) {
                        if (decpt <= 0) {
                                *buffer++ = '0';
                                *buffer++ = '.';
                                for (pos = 0; pos < -decpt; pos++)
                                        *buffer++ = '0';
                                while (*digits)
                                        *buffer++ = *digits++;
                        } else {
                                pos = 0;
                                while (*digits) {
                                        if (pos++ == decpt)
                                                *buffer++ = '.';
                                        *buffer++ = *digits++;
                                }
                        }
                } else {
                        *buffer++ = '0';
                        if (precision > 0) {
                                *buffer++ = '.';
                                for (pos = 0; pos < precision; pos++)
                                        *buffer++ = '0';
                        }
                }
        }
 
        *buffer = '\0';
}
 
static void decimal_point(char *buffer)
{
        while (*buffer) {
                if (*buffer == '.')
                        return;
                if (*buffer == 'e' || *buffer == 'E')
                        break;
                buffer++;
        }
 
        if (*buffer) {
                int n = strnlen(buffer, 256);
                while (n > 0) {
                        buffer[n + 1] = buffer[n];
                        n--;
                }
 
                *buffer = '.';
        } else {
                *buffer++ = '.';
                *buffer = '\0';
        }
}
 
static void cropzeros(char *buffer)
{
        char *stop;
 
        while (*buffer && *buffer != '.')
                buffer++;
        if (*buffer++) {
                while (*buffer && *buffer != 'e' && *buffer != 'E')
                        buffer++;
                stop = buffer--;
                while (*buffer == '0')
                        buffer--;
                if (*buffer == '.')
                        buffer--;
                while (buffer != stop)
                        *++buffer = 0;
        }
}
 
static char *flt(char *str, double num, int size, int precision, char fmt,
                 int flags)
{
        char tmp[80];
        char c, sign;
        int n, i;
 
        // Left align means no zero padding
        if (flags & LEFT)
                flags &= ~ZEROPAD;
 
        // Determine padding and sign char
        c = (flags & ZEROPAD) ? '0' : ' ';
        sign = 0;
        if (flags & SIGN) {
                if (num < 0.0) {
                        sign = '-';
                        num = -num;
                        size--;
                } else if (flags & PLUS) {
                        sign = '+';
                        size--;
                } else if (flags & SPACE) {
                        sign = ' ';
                        size--;
                }
        }
        // Compute the precision value
        if (precision < 0)
                precision = 6;  // Default precision: 6
 
        // Convert floating point number to text
        parse_float(num, tmp, fmt, precision);
 
        if ((flags & HEX_PREP) && precision == 0)
                decimal_point(tmp);
        if (fmt == 'g' && !(flags & HEX_PREP))
                cropzeros(tmp);
 
        n = strnlen(tmp, 256);
 
        // Output number with alignment and padding
        size -= n;
        if (!(flags & (ZEROPAD | LEFT)))
                while (size-- > 0)
                        *str++ = ' ';
        if (sign)
                *str++ = sign;
        if (!(flags & LEFT))
                while (size-- > 0)
                        *str++ = c;
        for (i = 0; i < n; i++)
                *str++ = tmp[i];
        while (size-- > 0)
                *str++ = ' ';
 
        return str;
}
 
#endif
 
static int ee_vsprintf(char *buf, const char *fmt, va_list args)
{
        int len;
        unsigned long num;
        int i, base;
        char *str;
        char *s;
 
        int flags;              // Flags to number()
 
        int field_width;        // Width of output field
        int precision;          // Min. # of digits for integers; max number of chars for from string
        int qualifier;          // 'h', 'l', or 'L' for integer fields
 
        for (str = buf; *fmt; fmt++) {
                if (*fmt != '%') {
                        *str++ = *fmt;
                        continue;
                }
                // Process flags
                flags = 0;
repeat:
                fmt++;          // This also skips first '%'
                switch (*fmt) {
                case '-':
                        flags |= LEFT;
                        goto repeat;
                case '+':
                        flags |= PLUS;
                        goto repeat;
                case ' ':
                        flags |= SPACE;
                        goto repeat;
                case '#':
                        flags |= HEX_PREP;
                        goto repeat;
                case '0':
                        flags |= ZEROPAD;
                        goto repeat;
                }
 
                // Get field width
                field_width = -1;
                if (is_digit(*fmt))
                        field_width = skip_atoi(&fmt);
                else if (*fmt == '*') {
                        fmt++;
                        field_width = va_arg(args, int);
                        if (field_width < 0) {
                                field_width = -field_width;
                                flags |= LEFT;
                        }
                }
                // Get the precision
                precision = -1;
                if (*fmt == '.') {
                        ++fmt;
                        if (is_digit(*fmt))
                                precision = skip_atoi(&fmt);
                        else if (*fmt == '*') {
                                ++fmt;
                                precision = va_arg(args, int);
                        }
                        if (precision < 0)
                                precision = 0;
                }
                // Get the conversion qualifier
                qualifier = -1;
                if (*fmt == 'l' || *fmt == 'L') {
                        qualifier = *fmt;
                        fmt++;
                }
                // Default base
                base = 10;
 
                switch (*fmt) {
                case 'c':
                        if (!(flags & LEFT))
                                while (--field_width > 0)
                                        *str++ = ' ';
                        *str++ = (unsigned char)va_arg(args, int);
                        while (--field_width > 0)
                                *str++ = ' ';
                        continue;
 
                case 's':
                        s = va_arg(args, char *);
                        if (!s)
                                s = "<NULL>";
                        len = strnlen(s, precision);
                        if (!(flags & LEFT))
                                while (len < field_width--)
                                        *str++ = ' ';
                        for (i = 0; i < len; ++i)
                                *str++ = *s++;
                        while (len < field_width--)
                                *str++ = ' ';
                        continue;
 
                case 'p':
                        if (field_width == -1) {
                                field_width = 2 * sizeof(void *);
                                flags |= ZEROPAD;
                        }
                        str =
                            number(str, (unsigned long)va_arg(args, void *), 16,
                                   field_width, precision, flags);
                        continue;
 
                case 'A':
                        flags |= UPPERCASE;
 
                case 'a':
                        if (qualifier == 'l')
                                str =
                                    eaddr(str, va_arg(args, unsigned char *),
                                          field_width, precision, flags);
                        else
                                str =
                                    iaddr(str, va_arg(args, unsigned char *),
                                          field_width, precision, flags);
                        continue;
 
                        // Integer number formats - set up the flags and "break"
                case 'o':
                        base = 8;
                        break;
 
                case 'X':
                        flags |= UPPERCASE;
 
                case 'x':
                        base = 16;
                        break;
 
                case 'd':
                case 'i':
                        flags |= SIGN;
 
                case 'u':
                        break;
 
#ifdef HAS_FLOAT
 
                case 'f':
                        str =
                            flt(str, va_arg(args, double), field_width,
                                precision, *fmt, flags | SIGN);
                        continue;
 
#endif
 
                default:
                        if (*fmt != '%')
                                *str++ = '%';
                        if (*fmt)
                                *str++ = *fmt;
                        else
                                --fmt;
                        continue;
                }
 
                if (qualifier == 'l')
                        num = va_arg(args, unsigned long);
                else if (flags & SIGN)
                        num = va_arg(args, int);
                else
                        num = va_arg(args, unsigned int);
 
                str = number(str, num, base, field_width, precision, flags);
        }
 
        *str = '\0';
        return str - buf;
}
 
void uart_send_char(char c)
{
 
        uart_putc(c);
 
}
 
int ee_printf(const char *fmt, ...)
{
        char buf[256], *p;
        va_list args;
        int n = 0;
 
        va_start(args, fmt);
        ee_vsprintf(buf, fmt, args);
        va_end(args);
        p = buf;
        while (*p) {
                uart_send_char(*p);
                n++;
                p++;
        }
 
        return n;
}

Line No.	Rev	Author	Line
1	355	julius	`/* File : barebones/ee_printf.c`
2			`This file contains an implementation of ee_printf that only requires a method to output a char to a UART without pulling in library code.`
3
4			`This code is based on a file that contains the following:`
5			`Copyright (C) 2002 Michael Ringgaard. All rights reserved.`
6
7			`Redistribution and use in source and binary forms, with or without`
8			`modification, are permitted provided that the following conditions`
9			`are met:`
10
11			`1. Redistributions of source code must retain the above copyright`
12			`notice, this list of conditions and the following disclaimer.`
13			`2. Redistributions in binary form must reproduce the above copyright`
14			`notice, this list of conditions and the following disclaimer in the`
15			`documentation and/or other materials provided with the distribution.`
16			`3. Neither the name of the project nor the names of its contributors`
17			`may be used to endorse or promote products derived from this software`
18			`without specific prior written permission.`
19
20			`THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND`
21			`ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE`
22			`IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE`
23			`ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE`
24			`FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL`
25			`DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS`
26			`OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)`
27			`HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT`
28			`LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY`
29			`OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF`
30			`SUCH DAMAGE.`
31
32			`*/`
33
34			`#include "coremark.h"`
35			`#include <stdarg.h>`
36			`#include "support.h"`
37			`#include "board.h"`
38			`#include "uart.h"`
39
40			`#define ZEROPAD (1<<0) /* Pad with zero */`
41			`#define SIGN (1<<1) /* Unsigned/signed long */`
42			`#define PLUS (1<<2) /* Show plus */`
43			`#define SPACE (1<<3) /* Spacer */`
44			`#define LEFT (1<<4) /* Left justified */`
45			`#define HEX_PREP (1<<5) /* 0x */`
46			`#define UPPERCASE (1<<6) /* 'ABCDEF' */`
47
48			`#define is_digit(c) ((c) >= '0' && (c) <= '9')`
49
50			`static char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";`
51			`static char *upper_digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";`
52			`static size_t strnlen(const char *s, size_t count);`
53
54			`static size_t strnlen(const char *s, size_t count)`
55			`{`
56	406	julius	`const char *sc;`
57			`for (sc = s; *sc != '\0' && count--; ++sc) ;`
58			`return sc - s;`
59	355	julius	`}`
60
61			`static int skip_atoi(const char **s)`
62			`{`
63	406	julius	`int i = 0;`
64			`while (is_digit(**s))`
65			`i = i * 10 + ((s)++) - '0';`
66			`return i;`
67	355	julius	`}`
68
69	406	julius	`static char number(char str, long num, int base, int size, int precision,`
70			`int type)`
71	355	julius	`{`
72	406	julius	`char c, sign, tmp[66];`
73			`char *dig = digits;`
74			`int i;`
75	355	julius
76	406	julius	`if (type & UPPERCASE)`
77			`dig = upper_digits;`
78			`if (type & LEFT)`
79			`type &= ~ZEROPAD;`
80			`if (base < 2 \|\| base > 36)`
81			`return 0;`
82	355	julius
83	406	julius	`c = (type & ZEROPAD) ? '0' : ' ';`
84			`sign = 0;`
85			`if (type & SIGN) {`
86			`if (num < 0) {`
87			`sign = '-';`
88			`num = -num;`
89			`size--;`
90			`} else if (type & PLUS) {`
91			`sign = '+';`
92			`size--;`
93			`} else if (type & SPACE) {`
94			`sign = ' ';`
95			`size--;`
96			`}`
97			`}`
98	355	julius
99	406	julius	`if (type & HEX_PREP) {`
100			`if (base == 16)`
101			`size -= 2;`
102			`else if (base == 8)`
103			`size--;`
104			`}`
105	355	julius
106	406	julius	`i = 0;`
107	355	julius
108	406	julius	`if (num == 0)`
109			`tmp[i++] = '0';`
110			`else {`
111			`while (num != 0) {`
112			`tmp[i++] = dig[((unsigned long)num) % (unsigned)base];`
113			`num = ((unsigned long)num) / (unsigned)base;`
114			`}`
115			`}`
116	355	julius
117	406	julius	`if (i > precision)`
118			`precision = i;`
119			`size -= precision;`
120			`if (!(type & (ZEROPAD \| LEFT)))`
121			`while (size-- > 0)`
122			`*str++ = ' ';`
123			`if (sign)`
124			`*str++ = sign;`
125	355	julius
126	406	julius	`if (type & HEX_PREP) {`
127			`if (base == 8)`
128			`*str++ = '0';`
129			`else if (base == 16) {`
130			`*str++ = '0';`
131			`*str++ = digits[33];`
132			`}`
133			`}`
134
135			`if (!(type & LEFT))`
136			`while (size-- > 0)`
137			`*str++ = c;`
138			`while (i < precision--)`
139			`*str++ = '0';`
140			`while (i-- > 0)`
141			`*str++ = tmp[i];`
142			`while (size-- > 0)`
143			`*str++ = ' ';`
144
145			`return str;`
146	355	julius	`}`
147
148	406	julius	`static char eaddr(char str, unsigned char *addr, int size, int precision,`
149			`int type)`
150	355	julius	`{`
151	406	julius	`char tmp[24];`
152			`char *dig = digits;`
153			`int i, len;`
154	355	julius
155	406	julius	`if (type & UPPERCASE)`
156			`dig = upper_digits;`
157			`len = 0;`
158			`for (i = 0; i < 6; i++) {`
159			`if (i != 0)`
160			`tmp[len++] = ':';`
161			`tmp[len++] = dig[addr[i] >> 4];`
162			`tmp[len++] = dig[addr[i] & 0x0F];`
163			`}`
164	355	julius
165	406	julius	`if (!(type & LEFT))`
166			`while (len < size--)`
167			`*str++ = ' ';`
168			`for (i = 0; i < len; ++i)`
169			`*str++ = tmp[i];`
170			`while (len < size--)`
171			`*str++ = ' ';`
172	355	julius
173	406	julius	`return str;`
174	355	julius	`}`
175
176	406	julius	`static char iaddr(char str, unsigned char *addr, int size, int precision,`
177			`int type)`
178	355	julius	`{`
179	406	julius	`char tmp[24];`
180			`int i, n, len;`
181	355	julius
182	406	julius	`len = 0;`
183			`for (i = 0; i < 4; i++) {`
184			`if (i != 0)`
185			`tmp[len++] = '.';`
186			`n = addr[i];`
187	355	julius
188	406	julius	`if (n == 0)`
189			`tmp[len++] = digits[0];`
190			`else {`
191			`if (n >= 100) {`
192			`tmp[len++] = digits[n / 100];`
193			`n = n % 100;`
194			`tmp[len++] = digits[n / 10];`
195			`n = n % 10;`
196			`} else if (n >= 10) {`
197			`tmp[len++] = digits[n / 10];`
198			`n = n % 10;`
199			`}`
200	355	julius
201	406	julius	`tmp[len++] = digits[n];`
202			`}`
203			`}`
204	355	julius
205	406	julius	`if (!(type & LEFT))`
206			`while (len < size--)`
207			`*str++ = ' ';`
208			`for (i = 0; i < len; ++i)`
209			`*str++ = tmp[i];`
210			`while (len < size--)`
211			`*str++ = ' ';`
212
213			`return str;`
214	355	julius	`}`
215
216			`#ifdef HAS_FLOAT`
217
218			`char ecvtbuf(double arg, int ndigits, int decpt, int sign, char buf);`
219			`char fcvtbuf(double arg, int ndigits, int decpt, int sign, char buf);`
220	406	julius	`static void ee_bufcpy(char d, char s, int count);`
221
222			`void ee_bufcpy(char pd, char ps, int count)`
223			`{`
224			`char *pe = ps + count;`
225			`while (ps != pe)`
226			`pd++ = ps++;`
227	355	julius	`}`
228
229			`static void parse_float(double value, char *buffer, char fmt, int precision)`
230			`{`
231	406	julius	`int decpt, sign, exp, pos;`
232			`char *digits = NULL;`
233			`char cvtbuf[80];`
234			`int capexp = 0;`
235			`int magnitude;`
236	355	julius
237	406	julius	`if (fmt == 'G' \|\| fmt == 'E') {`
238			`capexp = 1;`
239			`fmt += 'a' - 'A';`
240			`}`
241	355	julius
242	406	julius	`if (fmt == 'g') {`
243			`digits = ecvtbuf(value, precision, &decpt, &sign, cvtbuf);`
244			`magnitude = decpt - 1;`
245			`if (magnitude < -4 \|\| magnitude > precision - 1) {`
246			`fmt = 'e';`
247			`precision -= 1;`
248			`} else {`
249			`fmt = 'f';`
250			`precision -= decpt;`
251			`}`
252			`}`
253	355	julius
254	406	julius	`if (fmt == 'e') {`
255			`digits = ecvtbuf(value, precision + 1, &decpt, &sign, cvtbuf);`
256	355	julius
257	406	julius	`if (sign)`
258			`*buffer++ = '-';`
259			`buffer++ = digits;`
260			`if (precision > 0)`
261			`*buffer++ = '.';`
262			`ee_bufcpy(buffer, digits + 1, precision);`
263			`buffer += precision;`
264			`*buffer++ = capexp ? 'E' : 'e';`
265	355	julius
266	406	julius	`if (decpt == 0) {`
267			`if (value == 0.0)`
268			`exp = 0;`
269			`else`
270			`exp = -1;`
271			`} else`
272			`exp = decpt - 1;`
273	355	julius
274	406	julius	`if (exp < 0) {`
275			`*buffer++ = '-';`
276			`exp = -exp;`
277			`} else`
278			`*buffer++ = '+';`
279	355	julius
280	406	julius	`buffer[2] = (exp % 10) + '0';`
281			`exp = exp / 10;`
282			`buffer[1] = (exp % 10) + '0';`
283			`exp = exp / 10;`
284			`buffer[0] = (exp % 10) + '0';`
285			`buffer += 3;`
286			`} else if (fmt == 'f') {`
287			`digits = fcvtbuf(value, precision, &decpt, &sign, cvtbuf);`
288			`if (sign)`
289			`*buffer++ = '-';`
290			`if (*digits) {`
291			`if (decpt <= 0) {`
292			`*buffer++ = '0';`
293			`*buffer++ = '.';`
294			`for (pos = 0; pos < -decpt; pos++)`
295			`*buffer++ = '0';`
296			`while (*digits)`
297			`buffer++ = digits++;`
298			`} else {`
299			`pos = 0;`
300			`while (*digits) {`
301			`if (pos++ == decpt)`
302			`*buffer++ = '.';`
303			`buffer++ = digits++;`
304			`}`
305			`}`
306			`} else {`
307			`*buffer++ = '0';`
308			`if (precision > 0) {`
309			`*buffer++ = '.';`
310			`for (pos = 0; pos < precision; pos++)`
311			`*buffer++ = '0';`
312			`}`
313			`}`
314			`}`
315	355	julius
316	406	julius	`*buffer = '\0';`
317	355	julius	`}`
318
319			`static void decimal_point(char *buffer)`
320			`{`
321	406	julius	`while (*buffer) {`
322			`if (*buffer == '.')`
323			`return;`
324			`if (buffer == 'e' \|\| buffer == 'E')`
325			`break;`
326			`buffer++;`
327			`}`
328	355	julius
329	406	julius	`if (*buffer) {`
330			`int n = strnlen(buffer, 256);`
331			`while (n > 0) {`
332			`buffer[n + 1] = buffer[n];`
333			`n--;`
334			`}`
335	355	julius
336	406	julius	`*buffer = '.';`
337			`} else {`
338			`*buffer++ = '.';`
339			`*buffer = '\0';`
340			`}`
341	355	julius	`}`
342
343			`static void cropzeros(char *buffer)`
344			`{`
345	406	julius	`char *stop;`
346	355	julius
347	406	julius	`while (buffer && buffer != '.')`
348			`buffer++;`
349			`if (*buffer++) {`
350			`while (buffer && buffer != 'e' && *buffer != 'E')`
351			`buffer++;`
352			`stop = buffer--;`
353			`while (*buffer == '0')`
354			`buffer--;`
355			`if (*buffer == '.')`
356			`buffer--;`
357			`while (buffer != stop)`
358			`*++buffer = 0;`
359			`}`
360	355	julius	`}`
361
362	406	julius	`static char flt(char str, double num, int size, int precision, char fmt,`
363			`int flags)`
364	355	julius	`{`
365	406	julius	`char tmp[80];`
366			`char c, sign;`
367			`int n, i;`
368	355	julius
369	406	julius	`// Left align means no zero padding`
370			`if (flags & LEFT)`
371			`flags &= ~ZEROPAD;`
372	355	julius
373	406	julius	`// Determine padding and sign char`
374			`c = (flags & ZEROPAD) ? '0' : ' ';`
375			`sign = 0;`
376			`if (flags & SIGN) {`
377			`if (num < 0.0) {`
378			`sign = '-';`
379			`num = -num;`
380			`size--;`
381			`} else if (flags & PLUS) {`
382			`sign = '+';`
383			`size--;`
384			`} else if (flags & SPACE) {`
385			`sign = ' ';`
386			`size--;`
387			`}`
388			`}`
389			`// Compute the precision value`
390			`if (precision < 0)`
391			`precision = 6; // Default precision: 6`
392	355	julius
393	406	julius	`// Convert floating point number to text`
394			`parse_float(num, tmp, fmt, precision);`
395	355	julius
396	406	julius	`if ((flags & HEX_PREP) && precision == 0)`
397			`decimal_point(tmp);`
398			`if (fmt == 'g' && !(flags & HEX_PREP))`
399			`cropzeros(tmp);`
400	355	julius
401	406	julius	`n = strnlen(tmp, 256);`
402	355	julius
403	406	julius	`// Output number with alignment and padding`
404			`size -= n;`
405			`if (!(flags & (ZEROPAD \| LEFT)))`
406			`while (size-- > 0)`
407			`*str++ = ' ';`
408			`if (sign)`
409			`*str++ = sign;`
410			`if (!(flags & LEFT))`
411			`while (size-- > 0)`
412			`*str++ = c;`
413			`for (i = 0; i < n; i++)`
414			`*str++ = tmp[i];`
415			`while (size-- > 0)`
416			`*str++ = ' ';`
417	355	julius
418	406	julius	`return str;`
419	355	julius	`}`
420
421			`#endif`
422
423			`static int ee_vsprintf(char buf, const char fmt, va_list args)`
424			`{`
425	406	julius	`int len;`
426			`unsigned long num;`
427			`int i, base;`
428			`char *str;`
429			`char *s;`
430	355	julius
431	406	julius	`int flags; // Flags to number()`
432	355	julius
433	406	julius	`int field_width; // Width of output field`
434			`int precision; // Min. # of digits for integers; max number of chars for from string`
435			`int qualifier; // 'h', 'l', or 'L' for integer fields`
436	355	julius
437	406	julius	`for (str = buf; *fmt; fmt++) {`
438			`if (*fmt != '%') {`
439			`str++ = fmt;`
440			`continue;`
441			`}`
442			`// Process flags`
443			`flags = 0;`
444	355	julius	`repeat:`
445	406	julius	`fmt++; // This also skips first '%'`
446			`switch (*fmt) {`
447			`case '-':`
448			`flags \|= LEFT;`
449			`goto repeat;`
450			`case '+':`
451			`flags \|= PLUS;`
452			`goto repeat;`
453			`case ' ':`
454			`flags \|= SPACE;`
455			`goto repeat;`
456			`case '#':`
457			`flags \|= HEX_PREP;`
458			`goto repeat;`
459			`case '0':`
460			`flags \|= ZEROPAD;`
461			`goto repeat;`
462			`}`
463	355	julius
464	406	julius	`// Get field width`
465			`field_width = -1;`
466			`if (is_digit(*fmt))`
467			`field_width = skip_atoi(&fmt);`
468			`else if (fmt == '') {`
469			`fmt++;`
470			`field_width = va_arg(args, int);`
471			`if (field_width < 0) {`
472			`field_width = -field_width;`
473			`flags \|= LEFT;`
474			`}`
475			`}`
476			`// Get the precision`
477			`precision = -1;`
478			`if (*fmt == '.') {`
479			`++fmt;`
480			`if (is_digit(*fmt))`
481			`precision = skip_atoi(&fmt);`
482			`else if (fmt == '') {`
483			`++fmt;`
484			`precision = va_arg(args, int);`
485			`}`
486			`if (precision < 0)`
487			`precision = 0;`
488			`}`
489			`// Get the conversion qualifier`
490			`qualifier = -1;`
491			`if (fmt == 'l' \|\| fmt == 'L') {`
492			`qualifier = *fmt;`
493			`fmt++;`
494			`}`
495			`// Default base`
496			`base = 10;`
497	355	julius
498	406	julius	`switch (*fmt) {`
499			`case 'c':`
500			`if (!(flags & LEFT))`

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [bootloaders/] [orpmon/] [coremark/] [ee_printf.c] - Blame information for rev 639