Return to t.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb

Annotation of cci/usr/src/bin/cdb/t.c, revision 1.1.1.1

1.1       root        1: static char sccsid[] = "@(#)t.c        2.10";
                      2: 
                      3: #include <stdio.h>
                      4: /* this is a toy file used for testing cdb */
                      5: 
                      6: typedef enum {
                      7:        red, orange, yellow, green=10, blue, violet} 
                      8: COLORE;
                      9: 
                     10: 
                     11: typedef union {
                     12:        struct {
                     13:                int     s11;
                     14:        } 
                     15:        s1;
                     16:        struct {
                     17:                int     s21;
                     18:                int     s22;
                     19:        } 
                     20:        s2;
                     21:        struct {
                     22:                int     s31;
                     23:                int     s32;
                     24:                int     s33;
                     25:        } 
                     26:        s3;
                     27:        COLORE  color;
                     28: } 
                     29: U1U, *pU1U;
                     30: U1U    vu;
                     31: 
                     32: typedef struct {
                     33:        short   a;
                     34:        char    b[9];
                     35:        long    c;
                     36: unsigned foo1 : 
                     37:        1;
                     38: unsigned foo2 : 
                     39:        2;
                     40: unsigned foo3 : 
                     41:        3;
                     42: unsigned foo4 : 
                     43:        4;
                     44:        COLORE  color;
                     45: } 
                     46: MOMR, *pMOMR;
                     47: MOMR    vamom = {
                     48:        12, "Apple Pie", -34, 1, 2, 4, 8, green};
                     49: 
                     50: typedef union {
                     51:        long    lng;
                     52:        float   fl;
                     53:        struct {
                     54:                short       shortLo;
                     55:                short       shortHi;
                     56:        } 
                     57:        shorts;
                     58:        struct {
                     59:                char        chLoLo;
                     60:                char        chLoHi;
                     61:                char        chHiLo;
                     62:                char        chHiHi;
                     63:        } 
                     64:        chars;
                     65: } 
                     66: STUFFU;
                     67: 
                     68: STUFFU vstuff;
                     69: 
                     70: int     arI1[10];
                     71: int     arI2[5][6];
                     72: char    arC1[10];
                     73: char    arC2[5][6];
                     74: MOMR    vrgMom[4];
                     75: char   *mumble[5] = {
                     76:        "0", "1", "2", "3", "4"
                     77: };
                     78: 
                     79: int     k;
                     80: 
                     81: bar(a, b, c)
                     82: int     a, b, c;
                     83: {
                     84:        printf("in bar\n");
                     85:        baz(++a, -1L, "Hi, Mom!");
                     86: }
                     87: 
                     88: 
                     89: baz(d, e, f)
                     90: register int    d;
                     91: long    e;
                     92: char    *f;
                     93: {
                     94:        int         x, y, z;
                     95:        register float      fl;
                     96:        MOMR        amom;
                     97:        pMOMR       mom;
                     98: 
                     99:        mom = &amom;
                    100:        fl = 1.3;
                    101:        d = 2;
                    102:        e = d + e;
                    103:        switch (d) {
                    104:        case 0: 
                    105:                printf("0\n");  
                    106:                break;
                    107:        case 1: 
                    108:                printf("1\n");  
                    109:                break;
                    110:        case 2: 
                    111:                printf("2\n");  
                    112:                break;
                    113:        case 3: 
                    114:                printf("3\n");  
                    115:                break;
                    116:        case 4: 
                    117:                printf("4\n");  
                    118:                break;
                    119:        default:
                    120:                printf("default\n");    
                    121:                break;
                    122:        }
                    123:        printf("in baz  %s  %g\n",f, fl);
                    124: }
                    125: 
                    126: foo(i)
                    127: register int    i;
                    128: {
                    129:        printf("in foo\n");
                    130:        bar(++i, ++i, ++i);
                    131: }
                    132: 
                    133: int foo2(i, d)
                    134: int     i;
                    135: int d;
                    136: {
                    137:        int e;
                    138:        int x;
                    139:        long q;
                    140:        int y;
                    141: 
                    142:        printf("in foo2\n");
                    143:        bar(++i, ++i, ++i);
                    144:        return(i);
                    145: }
                    146: 
                    147: foo3(i, d, h, z)
                    148: int     i;
                    149: long d;
                    150: int     h;
                    151: int z;
                    152: {
                    153:        int e;
                    154:        long f;
                    155:        int m, n, o, p, q, r;
                    156: 
                    157:        printf("in foo3\n");
                    158:        bar(++i, ++i, ++i);
                    159:        return(i+d+h);
                    160: }
                    161: 
                    162: 
                    163: main(argc, argv)
                    164: int     argc;
                    165: char    *argv[];
                    166: {
                    167:        char        ch;
                    168:        char    *mumble[5];
                    169: 
                    170:        mumble[0] = "a";
                    171:        mumble[1] = "b";
                    172:        mumble[2] = "c";
                    173:        mumble[3] = "d";
                    174:        mumble[4] = "e";
                    175: 
                    176:        vstuff.lng = 0x12345678;
                    177:        vu.s3.s31 = 1;
                    178:        vu.s3.s32 = 2;
                    179:        vu.s3.s33 = 3;
                    180: 
                    181:        while (*argv)
                    182:                printf("%s\n",*(argv++));
                    183: 
                    184:        for (k=1; k != 0; k++) {
                    185:                foo(k);
                    186:        }
                    187:        printf("done\n");
                    188:        exit(0);
                    189: }

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