Return to back.c CVS log

Up to [Research Unix] / researchv10no / cmd / lcc / tst

Annotation of researchv10no/cmd/lcc/tst/back.c, revision 1.1

1.1     ! root        1: float af[10];
        !             2: char buffer[136], *cp, *limit, *s1, *s2, **ss;
        !             3: int bsize, i, *inc(), *ip, j, k, l, m, n, r;
        !             4: int a[10], b[10], xg[3][4], *yg[3];
        !             5: unsigned u;
        !             6: struct node {
        !             7:        int op, type;
        !             8:        struct node *kids[6];
        !             9: } *alloc(), nodes[10], *p, *q, **pp;
        !            10: char *strings[] = {"if", "for", "else", "while", 0 };
        !            11: 
        !            12: float f;
        !            13: double d;
        !            14: signed char c;
        !            15: signed int i;
        !            16: 
        !            17: main()
        !            18: {
        !            19:        return 0;
        !            20: }
        !            21: 
        !            22: features(xf, yf)
        !            23: int xf[][4], *yf[];
        !            24: {
        !            25:        int xl[3][4], *yl[3];
        !            26: 
        !            27:        /* simple expressions */
        !            28: 
        !            29:        i = 0;
        !            30:        i = i + 1;
        !            31:        i++;
        !            32:        ++i;
        !            33:        i += 2;
        !            34:        a[i] = b[i] = 1;
        !            35:        a[i] = a[i+j] = a[i-j+1] = 0;
        !            36:        n = 10*n + c - '0';
        !            37:        limit = &buffer[136 + 1 + bsize];
        !            38:        cp = limit = &buffer[136+1];
        !            39:        foo(0, i, a[i]+'0', &a[i]);
        !            40: 
        !            41:        /* control structures */
        !            42: 
        !            43:        for (i = 0; i < 15; i++);
        !            44:        if (c == ' ' || c == '\t' || c == '\n');
        !            45:        if (a[i] && a[i+j] && a[i-j+1]);
        !            46:        if (i+1);
        !            47:        if ((i = getchar()) != -1 && isletter(i) == 0);
        !            48:        if (c = isletter(c));
        !            49:        if (i=j);
        !            50:        if (i && s1 || s1 && *s1);
        !            51: 
        !            52:        /* structs */
        !            53:        
        !            54:        nodes[i].kids[0] = nodes[i].kids[1];
        !            55:        nodes[i].kids[0] = nodes[i].kids[1] = 0;
        !            56:        p->kids[0] = p->kids[1];
        !            57:        p->kids[i] = p->kids[i+1] = 0;
        !            58:        p++;
        !            59:        ++p;
        !            60:        p - q;
        !            61:        if (p > q);
        !            62:        alloc()->op++;
        !            63:        foo((*pp)->type);
        !            64:        foo(&(*pp)->type);
        !            65: 
        !            66:        /* character pointers */
        !            67: 
        !            68:        *s1;
        !            69:        *s1 = 0;
        !            70:        s1++;
        !            71:        ++s1;
        !            72:        *s1++ = 0;
        !            73:        *s1++ = c;
        !            74:        if (*s1 == 0);
        !            75:        if (*s1 == *s2);
        !            76:        if (*s1++ == 0);
        !            77:        s1 - s2;
        !            78:        *s1 - *s2;
        !            79:        if (s1 > s2);
        !            80:        if ((*--s1 = *--limit) != '\n');
        !            81:        if (*s1 && *s1 != '\n');
        !            82: 
        !            83:        /* pointer pointers */
        !            84: 
        !            85:        ss = strings;
        !            86:        *ss;
        !            87:        *ss = 0;
        !            88:        **ss = 0;
        !            89:        ss++;
        !            90: 
        !            91:        /* expressions with side effects */
        !            92: 
        !            93:        i = ++j;
        !            94:        i = j++;
        !            95:        *s1++ = *s2++ = 0;
        !            96:        *--s1 = *--s1 = 0;
        !            97:        (*inc())++;
        !            98:        i = (*inc())++;
        !            99:        af[i] += 1;
        !           100:        foo(i = j, --n, *s1++);
        !           101: 
        !           102:        /* multiply-dimensioned arrays */
        !           103: 
        !           104:        xg[i][j] = 0; yg[i][j] = 0;
        !           105:        xf[i][j] = 0; yf[i][j] = 0;
        !           106:        xl[i][j] = 0; yl[i][j] = 0;
        !           107: 
        !           108:        yg[i] = xg[i]; yg[i] = &xg[i][0];
        !           109:        yf[i] = xf[i]; yf[i] = &xf[i][0];
        !           110:        yl[i] = xl[i]; yl[i] = &xl[i][0];
        !           111: 
        !           112:        /* conditionals */
        !           113: 
        !           114:        i = j<3;
        !           115:        i = (i&&j) + (i||j);
        !           116:        i = i ? j : k;
        !           117:        i = i ? j : (k ? l : m);
        !           118:        i = i ? (j ? k : l) : m;
        !           119:        i = j ? 0 : foo();
        !           120: 
        !           121:        /* conversions */
        !           122: 
        !           123:        u = 0xffffffff;d = u;u = d;
        !           124: 
        !           125:        /* all operators */
        !           126: 
        !           127:        d+5;f+5;i+5;ip+5;u+5;
        !           128:        d-5;f-5;i-5;ip-5;ip-ip;u-5;
        !           129:        u&5;i&5;u|5;i|5;u^5;i^5;~u;~i;
        !           130:        i<<5;u<<5;i>>5;u>>5;
        !           131:        d*5;f*5;i*5;u*5;
        !           132:        d/5;f/5;i/5;u/5;
        !           133:        i%5;u%5;
        !           134:        -d;-f;-i;-u;
        !           135:        if (c==5);if (d==5);if (f==5);if (i==5);if (u==5);
        !           136:        s1=(char*) u;
        !           137: 
        !           138:        /* difficult calls and returns */
        !           139: 
        !           140:        foo(0)+foo(1);
        !           141:        foo(0)+foo(1)+foo(2);
        !           142: L1:    return i ? i++ : --i;
        !           143: L2:    return *ip = i++;
        !           144: L3:    return malloc(strlen(s1)+1);
        !           145: }
        !           146: 
        !           147: passold(c, d, f, i, p, u)
        !           148: char c, *p;
        !           149: double d;
        !           150: float f;
        !           151: int i;
        !           152: unsigned u;
        !           153: {
        !           154:        passold(c, d, f, i, p, u);
        !           155: }
        !           156: 
        !           157: passnew(char c, double d, float f, int i, char *p, unsigned u) {
        !           158:        passnew(c, d, f, i, p, u);
        !           159: }
        !           160: 
        !           161: typedef struct point { int x,y; } point;
        !           162: point structvalue(point p) {
        !           163:        point q;
        !           164: 
        !           165:        q = p;
        !           166:        p.y = 0;
        !           167:        q.y = 0;
        !           168:        if ((p=structvalue(p)).y)
        !           169:                return p;
        !           170:        else
        !           171:                return structvalue(p);
        !           172: }
        !           173: 
        !           174: struct node *alloc(){}
        !           175: foo(){}
        !           176: int *inc(){}
        !           177: isletter(){}

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