[BACK]Return to cordprnt.c CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc / cord

Annotation of OpenXM_contrib2/asir2000/gc/cord/cordprnt.c, Revision 1.1

1.1     ! noro        1: /*
        !             2:  * Copyright (c) 1993-1994 by Xerox Corporation.  All rights reserved.
        !             3:  *
        !             4:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
        !             5:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
        !             6:  *
        !             7:  * Permission is hereby granted to use or copy this program
        !             8:  * for any purpose,  provided the above notices are retained on all copies.
        !             9:  * Permission to modify the code and to distribute modified code is granted,
        !            10:  * provided the above notices are retained, and a notice that the code was
        !            11:  * modified is included with the above copyright notice.
        !            12:  */
        !            13: /* An sprintf implementation that understands cords.  This is probably */
        !            14: /* not terribly portable.  It assumes an ANSI stdarg.h.  It further    */
        !            15: /* assumes that I can make copies of va_list variables, and read       */
        !            16: /* arguments repeatedly by applyting va_arg to the copies.  This       */
        !            17: /* could be avoided at some performance cost.                          */
        !            18: /* We also assume that unsigned and signed integers of various kinds   */
        !            19: /* have the same sizes, and can be cast back and forth.                        */
        !            20: /* We assume that void * and char * have the same size.                        */
        !            21: /* All this cruft is needed because we want to rely on the underlying  */
        !            22: /* sprintf implementation whenever possible.                           */
        !            23: /* Boehm, September 21, 1995 6:00 pm PDT */
        !            24:
        !            25: #include "cord.h"
        !            26: #include "ec.h"
        !            27: #include <stdio.h>
        !            28: #include <stdarg.h>
        !            29: #include <string.h>
        !            30: #include "gc.h"
        !            31:
        !            32: #define CONV_SPEC_LEN 50       /* Maximum length of a single   */
        !            33:                                /* conversion specification.    */
        !            34: #define CONV_RESULT_LEN 50     /* Maximum length of any        */
        !            35:                                /* conversion with default      */
        !            36:                                /* width and prec.              */
        !            37:
        !            38:
        !            39: static int ec_len(CORD_ec x)
        !            40: {
        !            41:     return(CORD_len(x[0].ec_cord) + (x[0].ec_bufptr - x[0].ec_buf));
        !            42: }
        !            43:
        !            44: /* Possible nonumeric precision values.        */
        !            45: # define NONE -1
        !            46: # define VARIABLE -2
        !            47: /* Copy the conversion specification from CORD_pos into the buffer buf */
        !            48: /* Return negative on error.                                           */
        !            49: /* Source initially points one past the leading %.                     */
        !            50: /* It is left pointing at the conversion type.                         */
        !            51: /* Assign field width and precision to *width and *prec.               */
        !            52: /* If width or prec is *, VARIABLE is assigned.                                */
        !            53: /* Set *left to 1 if left adjustment flag is present.                  */
        !            54: /* Set *long_arg to 1 if long flag ('l' or 'L') is present, or to      */
        !            55: /* -1 if 'h' is present.                                               */
        !            56: static int extract_conv_spec(CORD_pos source, char *buf,
        !            57:                             int * width, int *prec, int *left, int * long_arg)
        !            58: {
        !            59:     register int result = 0;
        !            60:     register int current_number = 0;
        !            61:     register int saw_period = 0;
        !            62:     register int saw_number;
        !            63:     register int chars_so_far = 0;
        !            64:     register char current;
        !            65:
        !            66:     *width = NONE;
        !            67:     buf[chars_so_far++] = '%';
        !            68:     while(CORD_pos_valid(source)) {
        !            69:         if (chars_so_far >= CONV_SPEC_LEN) return(-1);
        !            70:         current = CORD_pos_fetch(source);
        !            71:         buf[chars_so_far++] = current;
        !            72:         switch(current) {
        !            73:          case '*':
        !            74:            saw_number = 1;
        !            75:            current_number = VARIABLE;
        !            76:            break;
        !            77:           case '0':
        !            78:             if (!saw_number) {
        !            79:                 /* Zero fill flag; ignore */
        !            80:                 break;
        !            81:             } /* otherwise fall through: */
        !            82:           case '1':
        !            83:          case '2':
        !            84:          case '3':
        !            85:          case '4':
        !            86:          case '5':
        !            87:           case '6':
        !            88:          case '7':
        !            89:          case '8':
        !            90:          case '9':
        !            91:            saw_number = 1;
        !            92:            current_number *= 10;
        !            93:            current_number += current - '0';
        !            94:            break;
        !            95:          case '.':
        !            96:            saw_period = 1;
        !            97:            if(saw_number) {
        !            98:                *width = current_number;
        !            99:                saw_number = 0;
        !           100:            }
        !           101:            current_number = 0;
        !           102:            break;
        !           103:          case 'l':
        !           104:          case 'L':
        !           105:            *long_arg = 1;
        !           106:            current_number = 0;
        !           107:            break;
        !           108:          case 'h':
        !           109:            *long_arg = -1;
        !           110:            current_number = 0;
        !           111:            break;
        !           112:          case ' ':
        !           113:          case '+':
        !           114:          case '#':
        !           115:            current_number = 0;
        !           116:            break;
        !           117:          case '-':
        !           118:            *left = 1;
        !           119:            current_number = 0;
        !           120:            break;
        !           121:          case 'd':
        !           122:          case 'i':
        !           123:          case 'o':
        !           124:          case 'u':
        !           125:          case 'x':
        !           126:          case 'X':
        !           127:          case 'f':
        !           128:          case 'e':
        !           129:          case 'E':
        !           130:          case 'g':
        !           131:          case 'G':
        !           132:          case 'c':
        !           133:          case 'C':
        !           134:          case 's':
        !           135:          case 'S':
        !           136:          case 'p':
        !           137:          case 'n':
        !           138:          case 'r':
        !           139:            goto done;
        !           140:           default:
        !           141:             return(-1);
        !           142:         }
        !           143:         CORD_next(source);
        !           144:     }
        !           145:     return(-1);
        !           146:   done:
        !           147:     if (saw_number) {
        !           148:        if (saw_period) {
        !           149:            *prec = current_number;
        !           150:        } else {
        !           151:            *prec = NONE;
        !           152:            *width = current_number;
        !           153:        }
        !           154:     } else {
        !           155:        *prec = NONE;
        !           156:     }
        !           157:     buf[chars_so_far] = '\0';
        !           158:     return(result);
        !           159: }
        !           160:
        !           161: int CORD_vsprintf(CORD * out, CORD format, va_list args)
        !           162: {
        !           163:     CORD_ec result;
        !           164:     register int count;
        !           165:     register char current;
        !           166:     CORD_pos pos;
        !           167:     char conv_spec[CONV_SPEC_LEN + 1];
        !           168:
        !           169:     CORD_ec_init(result);
        !           170:     for (CORD_set_pos(pos, format, 0); CORD_pos_valid(pos); CORD_next(pos)) {
        !           171:                current = CORD_pos_fetch(pos);
        !           172:                if (current == '%') {
        !           173:             CORD_next(pos);
        !           174:             if (!CORD_pos_valid(pos)) return(-1);
        !           175:             current = CORD_pos_fetch(pos);
        !           176:             if (current == '%') {
        !           177:                        CORD_ec_append(result, current);
        !           178:             } else {
        !           179:                int width, prec;
        !           180:                int left_adj = 0;
        !           181:                int long_arg = 0;
        !           182:                CORD arg;
        !           183:                size_t len;
        !           184:
        !           185:                if (extract_conv_spec(pos, conv_spec,
        !           186:                                      &width, &prec,
        !           187:                                      &left_adj, &long_arg) < 0) {
        !           188:                    return(-1);
        !           189:                }
        !           190:                current = CORD_pos_fetch(pos);
        !           191:                switch(current) {
        !           192:                    case 'n':
        !           193:                        /* Assign length to next arg */
        !           194:                        if (long_arg == 0) {
        !           195:                            int * pos_ptr;
        !           196:                            pos_ptr = va_arg(args, int *);
        !           197:                            *pos_ptr = ec_len(result);
        !           198:                        } else if (long_arg > 0) {
        !           199:                            long * pos_ptr;
        !           200:                            pos_ptr = va_arg(args, long *);
        !           201:                            *pos_ptr = ec_len(result);
        !           202:                        } else {
        !           203:                            short * pos_ptr;
        !           204:                            pos_ptr = va_arg(args, short *);
        !           205:                            *pos_ptr = ec_len(result);
        !           206:                        }
        !           207:                        goto done;
        !           208:                    case 'r':
        !           209:                        /* Append cord and any padding  */
        !           210:                        if (width == VARIABLE) width = va_arg(args, int);
        !           211:                        if (prec == VARIABLE) prec = va_arg(args, int);
        !           212:                        arg = va_arg(args, CORD);
        !           213:                        len = CORD_len(arg);
        !           214:                        if (prec != NONE && len > prec) {
        !           215:                          if (prec < 0) return(-1);
        !           216:                          arg = CORD_substr(arg, 0, prec);
        !           217:                          len = prec;
        !           218:                        }
        !           219:                        if (width != NONE && len < width) {
        !           220:                          char * blanks = GC_MALLOC_ATOMIC(width-len+1);
        !           221:
        !           222:                          memset(blanks, ' ', width-len);
        !           223:                          blanks[width-len] = '\0';
        !           224:                          if (left_adj) {
        !           225:                            arg = CORD_cat(arg, blanks);
        !           226:                          } else {
        !           227:                            arg = CORD_cat(blanks, arg);
        !           228:                          }
        !           229:                        }
        !           230:                        CORD_ec_append_cord(result, arg);
        !           231:                        goto done;
        !           232:                    case 'c':
        !           233:                        if (width == NONE && prec == NONE) {
        !           234:                            register char c;
        !           235:
        !           236:                            c = va_arg(args, char);
        !           237:                            CORD_ec_append(result, c);
        !           238:                            goto done;
        !           239:                        }
        !           240:                        break;
        !           241:                    case 's':
        !           242:                        if (width == NONE && prec == NONE) {
        !           243:                            char * str = va_arg(args, char *);
        !           244:                            register char c;
        !           245:
        !           246:                            while (c = *str++) {
        !           247:                                CORD_ec_append(result, c);
        !           248:                            }
        !           249:                            goto done;
        !           250:                        }
        !           251:                        break;
        !           252:                    default:
        !           253:                        break;
        !           254:                }
        !           255:                /* Use standard sprintf to perform conversion */
        !           256:                {
        !           257:                    register char * buf;
        !           258:                    va_list vsprintf_args = args;
        !           259:                        /* The above does not appear to be sanctioned   */
        !           260:                        /* by the ANSI C standard.                      */
        !           261:                    int max_size = 0;
        !           262:                    int res;
        !           263:
        !           264:                    if (width == VARIABLE) width = va_arg(args, int);
        !           265:                    if (prec == VARIABLE) prec = va_arg(args, int);
        !           266:                    if (width != NONE) max_size = width;
        !           267:                    if (prec != NONE && prec > max_size) max_size = prec;
        !           268:                    max_size += CONV_RESULT_LEN;
        !           269:                    if (max_size >= CORD_BUFSZ) {
        !           270:                        buf = GC_MALLOC_ATOMIC(max_size + 1);
        !           271:                    } else {
        !           272:                        if (CORD_BUFSZ - (result[0].ec_bufptr-result[0].ec_buf)
        !           273:                            < max_size) {
        !           274:                            CORD_ec_flush_buf(result);
        !           275:                        }
        !           276:                        buf = result[0].ec_bufptr;
        !           277:                    }
        !           278:                    switch(current) {
        !           279:                        case 'd':
        !           280:                        case 'i':
        !           281:                        case 'o':
        !           282:                        case 'u':
        !           283:                        case 'x':
        !           284:                        case 'X':
        !           285:                        case 'c':
        !           286:                            if (long_arg <= 0) {
        !           287:                              (void) va_arg(args, int);
        !           288:                            } else if (long_arg > 0) {
        !           289:                              (void) va_arg(args, long);
        !           290:                            }
        !           291:                            break;
        !           292:                        case 's':
        !           293:                        case 'p':
        !           294:                            (void) va_arg(args, char *);
        !           295:                            break;
        !           296:                        case 'f':
        !           297:                        case 'e':
        !           298:                        case 'E':
        !           299:                        case 'g':
        !           300:                        case 'G':
        !           301:                            (void) va_arg(args, double);
        !           302:                            break;
        !           303:                        default:
        !           304:                            return(-1);
        !           305:                    }
        !           306:                    res = vsprintf(buf, conv_spec, vsprintf_args);
        !           307:                    len = (size_t)res;
        !           308:                    if ((char *)(GC_word)res == buf) {
        !           309:                        /* old style vsprintf */
        !           310:                        len = strlen(buf);
        !           311:                    } else if (res < 0) {
        !           312:                        return(-1);
        !           313:                    }
        !           314:                    if (buf != result[0].ec_bufptr) {
        !           315:                        register char c;
        !           316:
        !           317:                        while (c = *buf++) {
        !           318:                            CORD_ec_append(result, c);
        !           319:                        }
        !           320:                    } else {
        !           321:                        result[0].ec_bufptr = buf + len;
        !           322:                    }
        !           323:                }
        !           324:               done:;
        !           325:             }
        !           326:         } else {
        !           327:             CORD_ec_append(result, current);
        !           328:         }
        !           329:     }
        !           330:     count = ec_len(result);
        !           331:     *out = CORD_balance(CORD_ec_to_cord(result));
        !           332:     return(count);
        !           333: }
        !           334:
        !           335: int CORD_sprintf(CORD * out, CORD format, ...)
        !           336: {
        !           337:     va_list args;
        !           338:     int result;
        !           339:
        !           340:     va_start(args, format);
        !           341:     result = CORD_vsprintf(out, format, args);
        !           342:     va_end(args);
        !           343:     return(result);
        !           344: }
        !           345:
        !           346: int CORD_fprintf(FILE * f, CORD format, ...)
        !           347: {
        !           348:     va_list args;
        !           349:     int result;
        !           350:     CORD out;
        !           351:
        !           352:     va_start(args, format);
        !           353:     result = CORD_vsprintf(&out, format, args);
        !           354:     va_end(args);
        !           355:     if (result > 0) CORD_put(out, f);
        !           356:     return(result);
        !           357: }
        !           358:
        !           359: int CORD_vfprintf(FILE * f, CORD format, va_list args)
        !           360: {
        !           361:     int result;
        !           362:     CORD out;
        !           363:
        !           364:     result = CORD_vsprintf(&out, format, args);
        !           365:     if (result > 0) CORD_put(out, f);
        !           366:     return(result);
        !           367: }
        !           368:
        !           369: int CORD_printf(CORD format, ...)
        !           370: {
        !           371:     va_list args;
        !           372:     int result;
        !           373:     CORD out;
        !           374:
        !           375:     va_start(args, format);
        !           376:     result = CORD_vsprintf(&out, format, args);
        !           377:     va_end(args);
        !           378:     if (result > 0) CORD_put(out, stdout);
        !           379:     return(result);
        !           380: }
        !           381:
        !           382: int CORD_vprintf(CORD format, va_list args)
        !           383: {
        !           384:     int result;
        !           385:     CORD out;
        !           386:
        !           387:     result = CORD_vsprintf(&out, format, args);
        !           388:     if (result > 0) CORD_put(out, stdout);
        !           389:     return(result);
        !           390: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>