Return to 2.i CVS log

Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests

Annotation of researchv10no/cmd/ccom/vax/tests/2.i, revision 1.1

1.1     ! root        1: foo(t1)
        !             2: {      register int i;
        !             3:        char j;
        !             4:        enum {x} b;
        !             5:        int t3;
        !             6:        register *ar1;
        !             7:        t3 = *(ar1++ + i) %= t1;
        !             8:        t3 = *ar1++ *= t1;
        !             9:        j = (int) foo >> 12;
        !            10:        t3 = *ar1++ &= t1;
        !            11:        t3 = *ar1++ <<= t1;
        !            12:        t3 = *ar1++ >>= t1;
        !            13:        f((short)b);
        !            14: }
        !            15: extern struct  _iobuf {
        !            16:        int     _cnt;
        !            17:        unsigned char   *_ptr;
        !            18:        unsigned char   *_base;
        !            19:        short   _flag;
        !            20:        char    _file;
        !            21: } _iob[120];
        !            22: a() {
        !            23:        register *x;
        !            24:        ((int)(*((&_iob[1]))->_ptr++=(*x++ >> 8)));
        !            25: }
        !            26: int g[1];
        !            27: b()
        !            28: {      int i, j;
        !            29:        register *a;
        !            30:        i = *a++ >>= j;
        !            31:        g[i] >>= 1;
        !            32: }
        !            33: struct  vstr    {
        !            34:        unsigned int    v_type:6;
        !            35:        unsigned int    v_amt:10;
        !            36: };
        !            37: struct xx {
        !            38:        struct  vstr    v[10];
        !            39: } x;
        !            40: maina()
        !            41: {      int i;
        !            42:        x.v[i].v_type = 1;
        !            43:        a(x.v[i].v_type);
        !            44: }
        !            45: struct foo { short a, b; } x3; int c ; char w;
        !            46: 
        !            47: mainb() { sub((w=0, x3)); }
        !            48: typedef struct Hinge
        !            49: {
        !            50:        unsigned fa:8, fb:8, ea:4, eb:4, reverse:1;
        !            51: } Hinge;
        !            52: Hinge hinges[10];
        !            53: int nhinges;
        !            54: 
        !            55: mainc()
        !            56: {      hinges[nhinges].fa = ggg();
        !            57: }
        !            58: short a3;
        !            59: zx()
        !            60: {      register int *b;
        !            61:        register short *c;
        !            62:        if(a3 & *b++);
        !            63:        if(*b++ & a3);
        !            64:        if(*++b & *c++);
        !            65:        if(*c++ & *++b);
        !            66: }
        !            67: a33()
        !            68: {      int i;
        !            69:        int c;
        !            70:        i = (c >>= 1);
        !            71: }
        !            72: int **noderepr();
        !            73: lenitem()
        !            74: {
        !            75:        register n;
        !            76:        return a(noderepr(n)[n/2]);
        !            77: }
        !            78: typedef struct {
        !            79:        int x, y;
        !            80: } coord;
        !            81: 
        !            82: struct thing {
        !            83:        coord t_pos;
        !            84:        int x;
        !            85: };
        !            86: rndmove(who)
        !            87: struct thing *who;
        !            88: {      static coord ret;
        !            89:        ret = who->t_pos;
        !            90: }
        !            91: typedef struct {int x,y;} point;
        !            92: point pt[10], lastpt, map();
        !            93: axx()
        !            94: {      int i;
        !            95:        pt[i] = lastpt = map();
        !            96: }
        !            97: struct a{int x,y;};
        !            98: maind()
        !            99: {      static struct a b, c, *x, *y;
        !           100:        b = c;
        !           101:        *x = *y = c;
        !           102: }
        !           103: struct {
        !           104:      int  d;
        !           105:      int  x;
        !           106: } s, *sp;
        !           107: 
        !           108: mainx() {
        !           109:        int x;  float f;
        !           110: 
        !           111:      sp->x = x + f * x;
        !           112: }

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