Annotation of researchv10no/cmd/lcc/ph/prec1b.c, revision 1.1.1.1

1.1       root        1: /* The Plum Hall Validation Suite for C
                      2:  * Unpublished copyright (c) 1986-1991, Chiron Systems Inc and Plum Hall Inc.
                      3:  * VERSION: 4
                      4:  * DATE: 1993-01-01
                      5:  * The "ANSI" mode of this suite corresponds to official ANSI C, X3.159-1989.
                      6:  * As per your license agreement, your distribution is not to be moved or copied outside the Designated Site
                      7:  * without specific permission from Plum Hall Inc.
                      8:  */
                      9: 
                     10: #include "defs.h"
                     11: 
                     12: /*
                     13:  * PREC1B -- try all operator pairs -- this file uses all binary operators
                     14:  * in the first position (see prec 2 for the other way around).
                     15:  */
                     16: 
                     17: static void p1_17();
                     18: static void p1_18();
                     19: static void p1_19();
                     20: static void p1_20();
                     21: static void p1_21();
                     22: static void p1_22();
                     23: static void p1_23();
                     24: static void p1_24();
                     25: static void p1_25();
                     26: static void p1_26();
                     27: static void p1_27();
                     28: static void p1_28();
                     29: static void p1_29();
                     30: static void p1_30();
                     31: static void p1_31();
                     32: static void p1_32();
                     33: static void p1_33();
                     34: static void p1_34();
                     35: static void p1_35();
                     36: 
                     37: void prec1b()
                     38:        {
                     39:        Filename = "prec1b.c";
                     40:        p1_17();        /* * */
                     41:        p1_18();        /* / */
                     42:        p1_19();        /* % */
                     43:        p1_20();        /* + */
                     44:        p1_21();        /* - */
                     45:        p1_22();        /* >> */
                     46:        p1_23();        /* << */
                     47:        p1_24();        /* > */
                     48:        p1_25();        /* < */
                     49:        p1_26();        /* >= */
                     50:        p1_27();        /* <= */
                     51:        p1_28();        /* == */
                     52:        p1_29();        /* != */
                     53:        p1_30();        /* & */
                     54:        p1_31();        /* ^ */
                     55:        p1_32();        /* | */
                     56:        p1_33();        /* && */
                     57:        p1_34();        /* || */
                     58:        p1_35();        /* ?= */
                     59:        }
                     60: 
                     61: /* X * Y */
                     62: static void p1_17()
                     63:        {
                     64:        int i = 4;
                     65:        int j = 3;
                     66:        int k = 2;
                     67:        iequals(__LINE__, i*j*k, 24);
                     68:        iequals(__LINE__, i*j/k, 6);
                     69:        iequals(__LINE__, i*j%k, 0);
                     70:        iequals(__LINE__, i*j+k, 14);
                     71:        iequals(__LINE__, i*j-k, 10);
                     72:        iequals(__LINE__, i*j>>k, 3);
                     73:        iequals(__LINE__, i*j<<k, 48);
                     74:        iequals(__LINE__, i*j>k, 1);
                     75:        iequals(__LINE__, i*j<k, 0);
                     76:        iequals(__LINE__, i*j<=k, 0);
                     77:        iequals(__LINE__, i*j>=k, 1);
                     78:        iequals(__LINE__, i*j==k, 0);
                     79:        iequals(__LINE__, i*j!=k, 1);
                     80:        iequals(__LINE__, i*j&k, 0);
                     81:        iequals(__LINE__, i*j^k, 14);
                     82:        iequals(__LINE__, i*j|k, 14);
                     83:        iequals(__LINE__, i*j&&k,1);
                     84:        iequals(__LINE__, i*j||k, 1);
                     85:        iequals(__LINE__, i*j?k:0, 2);
                     86:        /* X*Y=Z is illegal */
                     87:        /* X*Y*=Z is illegal */
                     88:        /* X*Y/=Z is illegal */
                     89:        /* X*Y%=Z is illegal */
                     90:        /* X*Y+=Z is illegal */
                     91:        /* X*Y-=Z is illegal */
                     92:        /* X*Y<<=Z is illegal */
                     93:        /* X*Y>>=Z is illegal */
                     94:        /* X*Y&=Z is illegal */
                     95:        /* X*Y^=Z is illegal */
                     96:        /* X*Y|=Z is illegal */
                     97:        iequals(__LINE__, (i*j,k), k);
                     98:        }
                     99: 
                    100: /* X / Y */
                    101: static void p1_18()
                    102:        {
                    103:        int i = 17;
                    104:        int j = 3;
                    105:        int k = 2;
                    106:        iequals(__LINE__, i/j/k, 2);
                    107:        iequals(__LINE__, i/j%k, 1);
                    108:        iequals(__LINE__, i/j+k, 7);
                    109:        iequals(__LINE__, i/j-k, 3);
                    110:        iequals(__LINE__, i/j>>k, 1);
                    111:        iequals(__LINE__, i/j<<k, 20);
                    112:        iequals(__LINE__, i/j>k, 1);
                    113:        iequals(__LINE__, i/j<k, 0);
                    114:        iequals(__LINE__, i/j<=k, 0);
                    115:        iequals(__LINE__, i/j>=k, 1);
                    116:        iequals(__LINE__, i/j==k, 0);
                    117:        iequals(__LINE__, i/j!=k, 1);
                    118:        iequals(__LINE__, i/j&k, 0);
                    119:        iequals(__LINE__, i/j^k, 7);
                    120:        iequals(__LINE__, i/j|k, 7);
                    121:        iequals(__LINE__, i/j&&k,1);
                    122:        iequals(__LINE__, i/j||k, 1);
                    123:        iequals(__LINE__, i/j?k:0, 2);
                    124:        /* X/Y=Z is illegal */
                    125:        /* X/Y*=Z is illegal */
                    126:        /* X/Y/=Z is illegal */
                    127:        /* X/Y%=Z is illegal */
                    128:        /* X/Y+=Z is illegal */
                    129:        /* X/Y-=Z is illegal */
                    130:        /* X/Y<<=Z is illegal */
                    131:        /* X/Y>>=Z is illegal */
                    132:        /* X/Y&=Z is illegal */
                    133:        /* X/Y^=Z is illegal */
                    134:        /* X/Y|=Z is illegal */
                    135:        iequals(__LINE__, (i/j,k), 2);
                    136:        }
                    137: 
                    138: /* X % Y */
                    139: static void p1_19()
                    140:        {
                    141:        int i = 17;
                    142:        int j = 10;
                    143:        int k = 2;
                    144:        iequals(__LINE__, i%j%k, 1);
                    145:        iequals(__LINE__, i%j+k, 9);
                    146:        iequals(__LINE__, i%j-k, 5);
                    147:        iequals(__LINE__, i%j>>k, 1);
                    148:        iequals(__LINE__, i%j<<k, 28);
                    149:        iequals(__LINE__, i%j>k, 1);
                    150:        iequals(__LINE__, i%j<k, 0);
                    151:        iequals(__LINE__, i%j<=k, 0);
                    152:        iequals(__LINE__, i%j>=k, 1);
                    153:        iequals(__LINE__, i%j==k, 0);
                    154:        iequals(__LINE__, i%j!=k, 1);
                    155:        iequals(__LINE__, i%j&k, 2);
                    156:        iequals(__LINE__, i%j^k, 5);
                    157:        iequals(__LINE__, i%j|k, 7);
                    158:        iequals(__LINE__, i%j&&k,1);
                    159:        iequals(__LINE__, i%j||k, 1);
                    160:        iequals(__LINE__, i%j?k:0, 2);
                    161:        /* X%Y=Z is illegal */
                    162:        /* X%Y*=Z is illegal */
                    163:        /* X%Y/=Z is illegal */
                    164:        /* X%Y%=Z is illegal */
                    165:        /* X%Y+=Z is illegal */
                    166:        /* X%Y-=Z is illegal */
                    167:        /* X%Y<<=Z is illegal */
                    168:        /* X%Y>>=Z is illegal */
                    169:        /* X%Y&=Z is illegal */
                    170:        /* X%Y^=Z is illegal */
                    171:        /* X%Y|=Z is illegal */
                    172:        iequals(__LINE__, (i%j,k), 2);
                    173:        }
                    174: 
                    175: /* X + Y */
                    176: static void p1_20()
                    177:        {
                    178:        int i = 4;
                    179:        int j = 3;
                    180:        int k = 2;
                    181:        iequals(__LINE__, i+j+k, 9);
                    182:        iequals(__LINE__, i+j-k, 5);
                    183:        iequals(__LINE__, i+j>>k, 1);
                    184:        iequals(__LINE__, i+j<<k, 28);
                    185:        iequals(__LINE__, i+j>k, 1);
                    186:        iequals(__LINE__, i+j<k, 0);
                    187:        iequals(__LINE__, i+j<=k, 0);
                    188:        iequals(__LINE__, i+j>=k, 1);
                    189:        iequals(__LINE__, i+j==k, 0);
                    190:        iequals(__LINE__, i+j!=k, 1);
                    191:        iequals(__LINE__, i+j&k, 2);
                    192:        iequals(__LINE__, i+j^k, 5);
                    193:        iequals(__LINE__, i+j|k, 7);
                    194:        iequals(__LINE__, i+j&&k,1);
                    195:        iequals(__LINE__, i+j||k, 1);
                    196:        iequals(__LINE__, i+j?k:0, 2);
                    197:        /* X+Y=Z is illegal */
                    198:        /* X+Y*=Z is illegal */
                    199:        /* X+Y/=Z is illegal */
                    200:        /* X+Y%=Z is illegal */
                    201:        /* X+Y+=Z is illegal */
                    202:        /* X+Y-=Z is illegal */
                    203:        /* X+Y<<=Z is illegal */
                    204:        /* X+Y>>=Z is illegal */
                    205:        /* X+Y&=Z is illegal */
                    206:        /* X+Y^=Z is illegal */
                    207:        /* X+Y|=Z is illegal */
                    208:        iequals(__LINE__, (i+j,k), 2);
                    209:        }
                    210: 
                    211: /* X - Y */
                    212: static void p1_21()
                    213:        {
                    214:        int i = 9;
                    215:        int j = 2;
                    216:        int k = 2;
                    217:        iequals(__LINE__, i-j-k, 5);
                    218:        iequals(__LINE__, i-j>>k, 1);
                    219:        iequals(__LINE__, i-j<<k, 28);
                    220:        iequals(__LINE__, i-j>k, 1);
                    221:        iequals(__LINE__, i-j<k, 0);
                    222:        iequals(__LINE__, i-j<=k, 0);
                    223:        iequals(__LINE__, i-j>=k, 1);
                    224:        iequals(__LINE__, i-j==k, 0);
                    225:        iequals(__LINE__, i-j!=k, 1);
                    226:        iequals(__LINE__, i-j&k, 2);
                    227:        iequals(__LINE__, i-j^k, 5);
                    228:        iequals(__LINE__, i-j|k, 7);
                    229:        iequals(__LINE__, i-j&&k,1);
                    230:        iequals(__LINE__, i-j||k, 1);
                    231:        iequals(__LINE__, i-j?k:0, 2);
                    232:        /* X-Y=Z is illegal */
                    233:        /* X-Y*=Z is illegal */
                    234:        /* X-Y/=Z is illegal */
                    235:        /* X-Y%=Z is illegal */
                    236:        /* X-Y+=Z is illegal */
                    237:        /* X-Y-=Z is illegal */
                    238:        /* X-Y<<=Z is illegal */
                    239:        /* X-Y>>=Z is illegal */
                    240:        /* X-Y&=Z is illegal */
                    241:        /* X-Y^=Z is illegal */
                    242:        /* X-Y|=Z is illegal */
                    243:        iequals(__LINE__, (i-j,k), 2);
                    244:        }
                    245: 
                    246: /* X >> Y */
                    247: static void p1_22()
                    248:        {
                    249:        int i = 28;
                    250:        int j = 2;
                    251:        int k = 2;
                    252:        iequals(__LINE__, i>>j>>k, 1);
                    253:        iequals(__LINE__, i>>j<<k, 28);
                    254:        iequals(__LINE__, i>>j>k, 1);
                    255:        iequals(__LINE__, i>>j<k, 0);
                    256:        iequals(__LINE__, i>>j<=k, 0);
                    257:        iequals(__LINE__, i>>j>=k, 1);
                    258:        iequals(__LINE__, i>>j==k, 0);
                    259:        iequals(__LINE__, i>>j!=k, 1);
                    260:        iequals(__LINE__, i>>j&k, 2);
                    261:        iequals(__LINE__, i>>j^k, 5);
                    262:        iequals(__LINE__, i>>j|k, 7);
                    263:        iequals(__LINE__, i>>j&&k,1);
                    264:        iequals(__LINE__, i>>j||k, 1);
                    265:        iequals(__LINE__, i>>j?k:0, 2);
                    266:        /* X>>Y=Z is illegal */
                    267:        /* X>>Y*=Z is illegal */
                    268:        /* X>>Y/=Z is illegal */
                    269:        /* X>>Y%=Z is illegal */
                    270:        /* X>>Y+=Z is illegal */
                    271:        /* X>>Y-=Z is illegal */
                    272:        /* X>>Y<<=Z is illegal */
                    273:        /* X>>Y>>=Z is illegal */
                    274:        /* X>>Y&=Z is illegal */
                    275:        /* X>>Y^=Z is illegal */
                    276:        /* X>>Y|=Z is illegal */
                    277:        iequals(__LINE__, (i>>j,k), 2);
                    278:        }
                    279: 
                    280: /* X << Y */
                    281: static void p1_23()
                    282:        {
                    283:        int i = 4;
                    284:        int j = 3;
                    285:        int k = 2;
                    286:        iequals(__LINE__, i<<j<<k, 128);
                    287:        iequals(__LINE__, i<<j>k, 1);
                    288:        iequals(__LINE__, i<<j<k, 0);
                    289:        iequals(__LINE__, i<<j<=k, 0);
                    290:        iequals(__LINE__, i<<j>=k, 1);
                    291:        iequals(__LINE__, i<<j==k, 0);
                    292:        iequals(__LINE__, i<<j!=k, 1);
                    293:        iequals(__LINE__, i<<j&k, 0);
                    294:        iequals(__LINE__, i<<j^k, 34);
                    295:        iequals(__LINE__, i<<j|k, 34);
                    296:        iequals(__LINE__, i<<j&&k,1);
                    297:        iequals(__LINE__, i<<j||k, 1);
                    298:        iequals(__LINE__, i<<j?k:0, 2);
                    299:        /* X<<Y=Z is illegal */
                    300:        /* X<<Y*=Z is illegal */
                    301:        /* X<<Y/=Z is illegal */
                    302:        /* X<<Y%=Z is illegal */
                    303:        /* X<<Y+=Z is illegal */
                    304:        /* X<<Y-=Z is illegal */
                    305:        /* X<<Y<<=Z is illegal */
                    306:        /* X<<Y>>=Z is illegal */
                    307:        /* X<<Y&=Z is illegal */
                    308:        /* X<<Y^=Z is illegal */
                    309:        /* X<<Y|=Z is illegal */
                    310:        iequals(__LINE__, (i<<j,k), 2);
                    311:        }
                    312: 
                    313: /* X > Y */
                    314: static void p1_24()
                    315:        {
                    316:        int i = 4;
                    317:        int j = 3;
                    318:        int k = 2;
                    319:        iequals(__LINE__, i>j>k, 0);
                    320:        iequals(__LINE__, i>j<k, 1);
                    321:        iequals(__LINE__, i>j<=k, 1);
                    322:        iequals(__LINE__, i>j>=k, 0);
                    323:        iequals(__LINE__, i>j==k, 0);
                    324:        iequals(__LINE__, i>j!=k, 1);
                    325:        iequals(__LINE__, i>j&k, 0);
                    326:        iequals(__LINE__, i>j^k, 3);
                    327:        iequals(__LINE__, i>j|k, 3);
                    328:        iequals(__LINE__, i>j&&k,1);
                    329:        iequals(__LINE__, i>j||k, 1);
                    330:        iequals(__LINE__, i>j?k:0, 2);
                    331:        /* X>Y=Z is illegal */
                    332:        /* X>Y*=Z is illegal */
                    333:        /* X>Y/=Z is illegal */
                    334:        /* X>Y%=Z is illegal */
                    335:        /* X>Y+=Z is illegal */
                    336:        /* X>Y-=Z is illegal */
                    337:        /* X>Y<<=Z is illegal */
                    338:        /* X>Y>>=Z is illegal */
                    339:        /* X>Y&=Z is illegal */
                    340:        /* X>Y^=Z is illegal */
                    341:        /* X>Y|=Z is illegal */
                    342:        iequals(__LINE__, (i>j,k), 2);
                    343:        }
                    344: 
                    345: /* X < Y */
                    346: static void p1_25()
                    347:        {
                    348:        int i = 4;
                    349:        int j = 3;
                    350:        int k = 2;
                    351:        iequals(__LINE__, i<j<k, 1);
                    352:        iequals(__LINE__, i<j<=k, 1);
                    353:        iequals(__LINE__, i<j>=k, 0);
                    354:        iequals(__LINE__, i<j==k, 0);
                    355:        iequals(__LINE__, i<j!=k, 1);
                    356:        iequals(__LINE__, i<j&k, 0);
                    357:        iequals(__LINE__, i<j^k, 2);
                    358:        iequals(__LINE__, i<j|k, 2);
                    359:        iequals(__LINE__, i<j&&k,0);
                    360:        iequals(__LINE__, i<j||k, 1);
                    361:        iequals(__LINE__, i<j?k:0, 0);
                    362:        /* X<Y=Z is illegal */
                    363:        /* X<Y*=Z is illegal */
                    364:        /* X<Y/=Z is illegal */
                    365:        /* X<Y%=Z is illegal */
                    366:        /* X<Y+=Z is illegal */
                    367:        /* X<Y-=Z is illegal */
                    368:        /* X<Y<<=Z is illegal */
                    369:        /* X<Y>>=Z is illegal */
                    370:        /* X<Y&=Z is illegal */
                    371:        /* X<Y^=Z is illegal */
                    372:        /* X<Y|=Z is illegal */
                    373:        iequals(__LINE__, (i<j,k), 2);
                    374:        }
                    375: 
                    376: /* X <= Y */
                    377: static void p1_26()
                    378:        {
                    379:        int i = 4;
                    380:        int j = 3;
                    381:        int k = 2;
                    382:        iequals(__LINE__, i<=j<=k, 1);
                    383:        iequals(__LINE__, i<=j>=k, 0);
                    384:        iequals(__LINE__, i<=j==k, 0);
                    385:        iequals(__LINE__, i<=j!=k, 1);
                    386:        iequals(__LINE__, i<=j&k, 0);
                    387:        iequals(__LINE__, i<=j^k, 2);
                    388:        iequals(__LINE__, i<=j|k, 2);
                    389:        iequals(__LINE__, i<=j&&k,0);
                    390:        iequals(__LINE__, i<=j||k, 1);
                    391:        iequals(__LINE__, i<=j?k:0, 0);
                    392:        /* X<=Y=Z is illegal */
                    393:        /* X<=Y*=Z is illegal */
                    394:        /* X<=Y/=Z is illegal */
                    395:        /* X<=Y%=Z is illegal */
                    396:        /* X<=Y+=Z is illegal */
                    397:        /* X<=Y-=Z is illegal */
                    398:        /* X<=Y<<=Z is illegal */
                    399:        /* X<=Y>>=Z is illegal */
                    400:        /* X<=Y&=Z is illegal */
                    401:        /* X<=Y^=Z is illegal */
                    402:        /* X<=Y|=Z is illegal */
                    403:        iequals(__LINE__, (i<=j,k), 2);
                    404:        }
                    405: 
                    406: /* X >= Y */
                    407: static void p1_27()
                    408:        {
                    409:        int i = 4;
                    410:        int j = 3;
                    411:        int k = 2;
                    412:        iequals(__LINE__, i>=j>=k, 0);
                    413:        iequals(__LINE__, i>=j==k, 0);
                    414:        iequals(__LINE__, i>=j!=k, 1);
                    415:        iequals(__LINE__, i>=j&k, 0);
                    416:        iequals(__LINE__, i>=j^k, 3);
                    417:        iequals(__LINE__, i>=j|k, 3);
                    418:        iequals(__LINE__, i>=j&&k,1);
                    419:        iequals(__LINE__, i>=j||k, 1);
                    420:        iequals(__LINE__, i>=j?k:0, 2);
                    421:        /* X>=Y=Z is illegal */
                    422:        /* X>=Y*=Z is illegal */
                    423:        /* X>=Y/=Z is illegal */
                    424:        /* X>=Y%=Z is illegal */
                    425:        /* X>=Y+=Z is illegal */
                    426:        /* X>=Y-=Z is illegal */
                    427:        /* X>=Y<<=Z is illegal */
                    428:        /* X>=Y>>=Z is illegal */
                    429:        /* X>=Y&=Z is illegal */
                    430:        /* X>=Y^=Z is illegal */
                    431:        /* X>=Y|=Z is illegal */
                    432:        iequals(__LINE__, (i>=j,k), 2);
                    433:        }
                    434: 
                    435: /* X == Y */
                    436: static void p1_28()
                    437:        {
                    438:        int i = 4;
                    439:        int j = 3;
                    440:        int k = 2;
                    441:        iequals(__LINE__, i==j==k, 0);
                    442:        iequals(__LINE__, i==j!=k, 1);
                    443:        iequals(__LINE__, i==j&k, 0);
                    444:        iequals(__LINE__, i==j^k, 2);
                    445:        iequals(__LINE__, i==j|k, 2);
                    446:        iequals(__LINE__, i==j&&k,0);
                    447:        iequals(__LINE__, i==j||k, 1);
                    448:        iequals(__LINE__, i==j?k:0, 0);
                    449:        /* X==Y=Z is illegal */
                    450:        /* X==Y*=Z is illegal */
                    451:        /* X==Y/=Z is illegal */
                    452:        /* X==Y%=Z is illegal */
                    453:        /* X==Y+=Z is illegal */
                    454:        /* X==Y-=Z is illegal */
                    455:        /* X==Y<<=Z is illegal */
                    456:        /* X==Y>>=Z is illegal */
                    457:        /* X==Y&=Z is illegal */
                    458:        /* X==Y^=Z is illegal */
                    459:        /* X==Y|=Z is illegal */
                    460:        iequals(__LINE__, (i==j,k), 2);
                    461:        }
                    462: 
                    463: /* X != Y */
                    464: static void p1_29()
                    465:        {
                    466:        int i = 4;
                    467:        int j = 3;
                    468:        int k = 2;
                    469:        iequals(__LINE__, i!=j!=k, 1);
                    470:        iequals(__LINE__, i!=j&k, 0);
                    471:        iequals(__LINE__, i!=j^k, 3);
                    472:        iequals(__LINE__, i!=j|k, 3);
                    473:        iequals(__LINE__, i!=j&&k,1);
                    474:        iequals(__LINE__, i!=j||k, 1);
                    475:        iequals(__LINE__, i!=j?k:0, 2);
                    476:        /* X!=Y=Z is illegal */
                    477:        /* X!=Y*=Z is illegal */
                    478:        /* X!=Y/=Z is illegal */
                    479:        /* X!=Y%=Z is illegal */
                    480:        /* X!=Y+=Z is illegal */
                    481:        /* X!=Y-=Z is illegal */
                    482:        /* X!=Y<<=Z is illegal */
                    483:        /* X!=Y>>=Z is illegal */
                    484:        /* X!=Y&=Z is illegal */
                    485:        /* X!=Y^=Z is illegal */
                    486:        /* X!=Y|=Z is illegal */
                    487:        iequals(__LINE__, (i!=j,k), 2);
                    488:        }
                    489: 
                    490: /* X & Y */
                    491: static void p1_30()
                    492:        {
                    493:        int i = 4;
                    494:        int j = 3;
                    495:        int k = 2;
                    496:        iequals(__LINE__, i&j&k, 0);
                    497:        iequals(__LINE__, i&j^k, 2);
                    498:        iequals(__LINE__, i&j|k, 2);
                    499:        iequals(__LINE__, i&j&&k,0);
                    500:        iequals(__LINE__, i&j||k, 1);
                    501:        iequals(__LINE__, i&j?k:0, 0);
                    502:        /* X&Y=Z is illegal */
                    503:        /* X&Y*=Z is illegal */
                    504:        /* X&Y/=Z is illegal */
                    505:        /* X&Y%=Z is illegal */
                    506:        /* X&Y+=Z is illegal */
                    507:        /* X&Y-=Z is illegal */
                    508:        /* X&Y<<=Z is illegal */
                    509:        /* X&Y>>=Z is illegal */
                    510:        /* X&Y&=Z is illegal */
                    511:        /* X&Y^=Z is illegal */
                    512:        /* X&Y|=Z is illegal */
                    513:        iequals(__LINE__, (i&j,k), 2);
                    514:        }
                    515: 
                    516: /* X ^ Y */
                    517: static void p1_31()
                    518:        {
                    519:        int i = 4;
                    520:        int j = 3;
                    521:        int k = 2;
                    522:        iequals(__LINE__, i^j^k, 5);
                    523:        iequals(__LINE__, i^j|k, 7);
                    524:        iequals(__LINE__, i^j&&k,1);
                    525:        iequals(__LINE__, i^j||k, 1);
                    526:        iequals(__LINE__, i^j?k:0, 2);
                    527:        /* X^Y=Z is illegal */
                    528:        /* X^Y*=Z is illegal */
                    529:        /* X^Y/=Z is illegal */
                    530:        /* X^Y%=Z is illegal */
                    531:        /* X^Y+=Z is illegal */
                    532:        /* X^Y-=Z is illegal */
                    533:        /* X^Y<<=Z is illegal */
                    534:        /* X^Y>>=Z is illegal */
                    535:        /* X^Y&=Z is illegal */
                    536:        /* X^Y^=Z is illegal */
                    537:        /* X^Y|=Z is illegal */
                    538:        iequals(__LINE__, (i^j,k), 2);
                    539:        }
                    540: 
                    541: /* X | Y */
                    542: static void p1_32()
                    543:        {
                    544:        int i = 4;
                    545:        int j = 3;
                    546:        int k = 2;
                    547:        iequals(__LINE__, i|j|k, 7);
                    548:        iequals(__LINE__, i|j&&k,1);
                    549:        iequals(__LINE__, i|j||k, 1);
                    550:        iequals(__LINE__, i|j?k:0, 2);
                    551:        /* X|Y=Z is illegal */
                    552:        /* X|Y*=Z is illegal */
                    553:        /* X|Y/=Z is illegal */
                    554:        /* X|Y%=Z is illegal */
                    555:        /* X|Y+=Z is illegal */
                    556:        /* X|Y-=Z is illegal */
                    557:        /* X|Y<<=Z is illegal */
                    558:        /* X|Y>>=Z is illegal */
                    559:        /* X|Y&=Z is illegal */
                    560:        /* X|Y^=Z is illegal */
                    561:        /* X|Y|=Z is illegal */
                    562:        iequals(__LINE__, (i|j,k), 2);
                    563:        }
                    564: 
                    565: /* X && Y */
                    566: static void p1_33()
                    567:        {
                    568:        int i = 4;
                    569:        int j = 3;
                    570:        int k = 2;
                    571:        iequals(__LINE__, i&&j&&k, 1);
                    572:        iequals(__LINE__, i&&j||k, 1);
                    573:        iequals(__LINE__, i&&j?k:0, 2);
                    574:        /* X&&Y=Z is illegal */
                    575:        /* X&&Y*=Z is illegal */
                    576:        /* X&&Y/=Z is illegal */
                    577:        /* X&&Y%=Z is illegal */
                    578:        /* X&&Y+=Z is illegal */
                    579:        /* X&&Y-=Z is illegal */
                    580:        /* X&&Y<<=Z is illegal */
                    581:        /* X&&Y>>=Z is illegal */
                    582:        /* X&&Y&=Z is illegal */
                    583:        /* X&&Y^=Z is illegal */
                    584:        /* X&&Y|=Z is illegal */
                    585:        iequals(__LINE__, (i&&j,k), 2);
                    586:        }
                    587: 
                    588: /* X || Y */
                    589: static void p1_34()
                    590:        {
                    591:        int i = 4;
                    592:        int j = 3;
                    593:        int k = 2;
                    594:        iequals(__LINE__, i||j||k, 1);
                    595:        iequals(__LINE__, i||j?k:0, 2);
                    596:        /* X||Y=Z is illegal */
                    597:        /* X||Y*=Z is illegal */
                    598:        /* X||Y/=Z is illegal */
                    599:        /* X||Y%=Z is illegal */
                    600:        /* X||Y+=Z is illegal */
                    601:        /* X||Y-=Z is illegal */
                    602:        /* X||Y<<=Z is illegal */
                    603:        /* X||Y>>=Z is illegal */
                    604:        /* X||Y&=Z is illegal */
                    605:        /* X||Y^=Z is illegal */
                    606:        /* X||Y|=Z is illegal */
                    607:        iequals(__LINE__, (i||j,k), 2);
                    608:        }
                    609: 
                    610: /* X ? Y : Z */
                    611: static void p1_35()
                    612:        {
                    613:        int i = 0;
                    614:        int j = 3;
                    615:        int k = 2;
                    616:        iequals(__LINE__, i? j : j?k:0, 2);
                    617:        /* X?:Y=Z is illegal */
                    618:        /* X?:Y*=Z is illegal */
                    619:        /* X?:Y/=Z is illegal */
                    620:        /* X?:Y%=Z is illegal */
                    621:        /* X?:Y+=Z is illegal */
                    622:        /* X?:Y-=Z is illegal */
                    623:        /* X?:Y<<=Z is illegal */
                    624:        /* X?:Y>>=Z is illegal */
                    625:        /* X?:Y&=Z is illegal */
                    626:        /* X?:Y^=Z is illegal */
                    627:        /* X?:Y|=Z is illegal */
                    628:        iequals(__LINE__, (i?j:j,k), 2);
                    629:        }
                    630: 

unix.superglobalmegacorp.com

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