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

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.