Return to format.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / pi

Annotation of researchv9/jtools/src/pi/format.c, revision 1.1

1.1     ! root        1: #include "univ.h"
        !             2: #include "format.pri"
        !             3: #include <ctype.h>
        !             4: #include "symtab.pub"
        !             5: #include "symbol.h"
        !             6: SRCFILE("format.c")
        !             7: 
        !             8: char *Bls::af(PRINTF_ARGS)
        !             9: {
        !            10:        char x[1024], *q = x;
        !            11: 
        !            12:        trace( "%d.af(%s ...) %s", this, fmt, text );
        !            13:        IF_LIVE(!this) return "Bls::af";
        !            14:        if( p<text+TBLS && fmt ){
        !            15:                sprintf(x, PRINTF_COPY);
        !            16:                while( *q && p<text+TBLS ) *p++ = *q++;
        !            17:                *p = 0;
        !            18:        }
        !            19:        return text;
        !            20: }
        !            21: 
        !            22: Bls::Bls(PRINTF_ARGS)
        !            23: {
        !            24:        clear();
        !            25:        af(PRINTF_COPY);
        !            26: }
        !            27: 
        !            28: Bls::Bls(Bls &b)
        !            29: {
        !            30:        clear();
        !            31:        af("%s", b.text);
        !            32: }
        !            33: 
        !            34: Format::Format(long f, SymTab *s)      { format = f; stab = s; }
        !            35: 
        !            36: char *FmtByte(int c)
        !            37: {      static char buf[8];
        !            38: 
        !            39:        switch( c &= 0xFF ){
        !            40:        case '\0'       : return "\\0"; 
        !            41:        case '\b'       : return "\\b"; 
        !            42:        case '\f'       : return "\\f"; 
        !            43:        case '\n'       : return "\\n"; 
        !            44:        case '\r'       : return "\\r"; 
        !            45:        case '\t'       : return "\\t"; 
        !            46:        case '\v'       : return "\\v"; 
        !            47:        case ' '        : return " ";           /* see ikeya!<ctype.h> */       
        !            48:        case '\''       : return "\\\'";
        !            49:        case '\"'       : return "\\\"";
        !            50:        case '\\'       : return "\\\\";
        !            51:        }
        !            52:        sprintf( buf, isascii(c)&&isprint(c)?"%c":"\\%03o", c );
        !            53:        return buf;
        !            54: }
        !            55: 
        !            56: char *FmtAscii(unsigned long c)
        !            57: {
        !            58:        static char buf[32];
        !            59: 
        !            60:        if( c == 0 ) return "0";
        !            61:        strcpy(buf, "'");
        !            62:        int lead = 1; int byte = 4;                     // cfront bug
        !            63:        for( ; byte; --byte, c<<=8 ){
        !            64:                if( (c&0xFF000000) || !lead ){
        !            65:                        strcat(buf, FmtByte(c>>24));
        !            66:                        lead = 0;
        !            67:                }
        !            68:        }
        !            69:        return strcat(buf, "'");
        !            70: }
        !            71: 
        !            72: void Format::grow(char *b)
        !            73: {
        !            74:        accum.af("%s%s", sep, b);
        !            75:        sep = "=";
        !            76: }
        !            77: 
        !            78: void Format::growtime(long t)
        !            79: {
        !            80:        char *time(long*);
        !            81:        grow(ctime(&t));
        !            82: }
        !            83:        
        !            84: void Format::grow(char *fmt, long l)
        !            85: {
        !            86:        char buf[32];
        !            87: 
        !            88:        sprintf(buf, fmt, l);
        !            89:        grow(buf);
        !            90: }
        !            91: 
        !            92: void Format::grow(char *fmt, double d)
        !            93: {
        !            94:        char buf[32];
        !            95: 
        !            96:        trace( "%d.grow(%s,%g)", this, fmt, d );
        !            97:        sprintf(buf, fmt, d);
        !            98:        if( fmt[1]=='g' && !strcmp(buf, "0") )
        !            99:                grow("0.0");
        !           100:        else
        !           101:                grow(buf);
        !           102: }
        !           103: 
        !           104: char *Format::f(long lng, double dbl)
        !           105: {
        !           106:        Symbol *s;
        !           107: 
        !           108:        if( !this ) return "Format::f";
        !           109: 
        !           110:        accum.clear();
        !           111:        sep = "";
        !           112: 
        !           113:        if( !format ) format = F_HEX;
        !           114: 
        !           115:        if( format&F_MASK8  ) lng &= 0xFF;
        !           116:        if( format&F_MASK16 ) lng &= 0xFFFF;
        !           117: 
        !           118:        if( format&F_FLOAT  ) grow("%g",      dbl);
        !           119:        if( format&F_DOUBLE ) grow("%g",      dbl);
        !           120:        if( format&F_DBLHEX ) grow("0x%X_%X", dbl);
        !           121: 
        !           122:        if( format&F_SYMBOLIC
        !           123:         && lng
        !           124:         && stab
        !           125:         && (s = stab->loctosym(SSet(U_FUNC,U_GLB,U_STA,U_STMT), lng)) ){
        !           126:                lng -= s->range.lo;
        !           127:                grow(s->text());
        !           128:                if( !lng )
        !           129:                        format = 0;
        !           130:                else {
        !           131:                        sep =  "+";
        !           132:                        if( !(format&F_HOAD) ) format |= F_HEX;
        !           133:                }
        !           134:        }
        !           135: 
        !           136:        if( format&F_TIME ) growtime(lng);
        !           137:        if( (format&F_HOAD) && lng>=0 && lng<=7 ) grow("%d", lng);
        !           138:        else {
        !           139:                if( format&F_OCTAL   ) grow("0%o",  lng);
        !           140:                if( format&F_DECIMAL ) grow("%u",   lng);
        !           141:                if( format&F_HEX     ) grow("0x%X", lng);
        !           142:                if( format&F_ASCII   ) grow(FmtAscii(lng));
        !           143: 
        !           144:                if( format&F_EXT8 ) lng = (char ) lng;
        !           145:                if( format&F_EXT16) lng = (short) lng;
        !           146: 
        !           147:                if( format&F_SIGNED
        !           148:                 && (lng<0 || !(format&F_DECIMAL)) ) grow("%d", lng);
        !           149:        }
        !           150:        return accum.text;
        !           151: }

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