Annotation of researchv10no/cmd/lcc/ph/compl.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 the Suite corresponds to the 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: #define ANSI 1  /* This file follows ANSI arithmetic rules, which may not work in non-ANSI modes */
                     11: #include "types.h"
                     12: #include "m.h"
                     13: int main()
                     14:        {
                     15:        extern char *Filename;
                     16:        auto CHAR Cc = 7;
                     17:        auto CHAR *pCc = &Cc;
                     18:        auto CHAR **ppCc = &pCc;
                     19: #if ANSI
                     20:        auto SCHAR Csc = 8;
                     21:        auto SCHAR *pCsc = &Csc;
                     22:        auto SCHAR **ppCsc = &pCsc;
                     23: #endif
                     24:        auto SHORT Cs = 9;
                     25:        auto SHORT *pCs = &Cs;
                     26:        auto SHORT **ppCs = &pCs;
                     27:        auto INT Ci = 10;
                     28:        auto INT *pCi = &Ci;
                     29:        auto INT **ppCi = &pCi;
                     30:        auto UCHAR Cuc = 11;
                     31:        auto UCHAR *pCuc = &Cuc;
                     32:        auto UCHAR **ppCuc = &pCuc;
                     33:        auto USHORT Cus = 12;
                     34:        auto USHORT *pCus = &Cus;
                     35:        auto USHORT **ppCus = &pCus;
                     36:        auto UINT Cui = 13;
                     37:        auto UINT *pCui = &Cui;
                     38:        auto UINT **ppCui = &pCui;
                     39:        auto LONG Cl = 14;
                     40:        auto LONG *pCl = &Cl;
                     41:        auto LONG **ppCl = &pCl;
                     42:        auto ULONG Cul = 15;
                     43:        auto ULONG *pCul = &Cul;
                     44:        auto ULONG **ppCul = &pCul;
                     45:        auto FLOAT Cf = 16;
                     46:        auto FLOAT *pCf = &Cf;
                     47:        auto FLOAT **ppCf = &pCf;
                     48:        auto DOUBLE Cd = 17;
                     49:        auto DOUBLE *pCd = &Cd;
                     50:        auto DOUBLE **ppCd = &pCd;
                     51: #if ANSI
                     52:        auto LDOUBLE Cld = 18;
                     53:        auto LDOUBLE *pCld = &Cld;
                     54:        auto LDOUBLE **ppCld = &pCld;
                     55: #endif
                     56:        {
                     57:        CHAR Mc();
                     58: #if ANSI
                     59:        SCHAR Msc();
                     60: #endif
                     61:        SHORT Ms();
                     62:        INT Mi();
                     63:        UCHAR Muc();
                     64:        USHORT Mus();
                     65:        UINT Mui();
                     66:        LONG Ml();
                     67:        ULONG Mul();
                     68:        FLOAT Mf();
                     69:        DOUBLE Md();
                     70: #if ANSI
                     71:        LDOUBLE Mld();
                     72: #endif
                     73:        {
                     74:        int true = 1, false = 0;
                     75:        Filename =  " auto pscalar2 auto func compl ";
                     76:        iequals(__LINE__, ~ **ppCc, ~7);
                     77:        iequals(__LINE__, ~ Mc(), ~7);
                     78: #if ANSI
                     79:        iequals(__LINE__, ~ **ppCc, ~7);
                     80:        iequals(__LINE__, ~ Msc(), ~8);
                     81: #endif
                     82:        iequals(__LINE__, ~ **ppCc, ~7);
                     83:        iequals(__LINE__, ~ Ms(), ~9);
                     84:        iequals(__LINE__, ~ **ppCc, ~7);
                     85:        iequals(__LINE__, ~ Mi(), ~10);
                     86:        iequals(__LINE__, ~ **ppCc, ~7);
                     87:        iequals(__LINE__, ~ (int)Muc(), ~11);
                     88:        iequals(__LINE__, ~ **ppCc, ~7);
                     89:        iequals(__LINE__, ~ (int)Mus(), ~12);
                     90:        iequals(__LINE__, ~ **ppCc, ~7);
                     91:        iequals(__LINE__, ~ (int)Mui(), ~13);
                     92:        iequals(__LINE__, ~ **ppCc, ~7);
                     93:        lequals(__LINE__, ~ Ml(), ~14L);
                     94:        iequals(__LINE__, ~ **ppCc, ~7);
                     95:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                     96: #if ANSI
                     97:        iequals(__LINE__, ~ **ppCsc, ~8);
                     98:        iequals(__LINE__, ~ Mc(), ~7);
                     99: #endif
                    100: #if ANSI
                    101:        iequals(__LINE__, ~ **ppCsc, ~8);
                    102:        iequals(__LINE__, ~ Msc(), ~8);
                    103: #endif
                    104: #if ANSI
                    105:        iequals(__LINE__, ~ **ppCsc, ~8);
                    106:        iequals(__LINE__, ~ Ms(), ~9);
                    107: #endif
                    108: #if ANSI
                    109:        iequals(__LINE__, ~ **ppCsc, ~8);
                    110:        iequals(__LINE__, ~ Mi(), ~10);
                    111: #endif
                    112: #if ANSI
                    113:        iequals(__LINE__, ~ **ppCsc, ~8);
                    114:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    115: #endif
                    116: #if ANSI
                    117:        iequals(__LINE__, ~ **ppCsc, ~8);
                    118:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    119: #endif
                    120: #if ANSI
                    121:        iequals(__LINE__, ~ **ppCsc, ~8);
                    122:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    123: #endif
                    124: #if ANSI
                    125:        iequals(__LINE__, ~ **ppCsc, ~8);
                    126:        lequals(__LINE__, ~ Ml(), ~14L);
                    127: #endif
                    128: #if ANSI
                    129:        iequals(__LINE__, ~ **ppCsc, ~8);
                    130:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    131: #endif
                    132:        iequals(__LINE__, ~ **ppCs, ~9);
                    133:        iequals(__LINE__, ~ Mc(), ~7);
                    134: #if ANSI
                    135:        iequals(__LINE__, ~ **ppCs, ~9);
                    136:        iequals(__LINE__, ~ Msc(), ~8);
                    137: #endif
                    138:        iequals(__LINE__, ~ **ppCs, ~9);
                    139:        iequals(__LINE__, ~ Ms(), ~9);
                    140:        iequals(__LINE__, ~ **ppCs, ~9);
                    141:        iequals(__LINE__, ~ Mi(), ~10);
                    142:        iequals(__LINE__, ~ **ppCs, ~9);
                    143:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    144:        iequals(__LINE__, ~ **ppCs, ~9);
                    145:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    146:        iequals(__LINE__, ~ **ppCs, ~9);
                    147:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    148:        iequals(__LINE__, ~ **ppCs, ~9);
                    149:        lequals(__LINE__, ~ Ml(), ~14L);
                    150:        iequals(__LINE__, ~ **ppCs, ~9);
                    151:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    152:        iequals(__LINE__, ~ **ppCi, ~10);
                    153:        iequals(__LINE__, ~ Mc(), ~7);
                    154: #if ANSI
                    155:        iequals(__LINE__, ~ **ppCi, ~10);
                    156:        iequals(__LINE__, ~ Msc(), ~8);
                    157: #endif
                    158:        iequals(__LINE__, ~ **ppCi, ~10);
                    159:        iequals(__LINE__, ~ Ms(), ~9);
                    160:        iequals(__LINE__, ~ **ppCi, ~10);
                    161:        iequals(__LINE__, ~ Mi(), ~10);
                    162:        iequals(__LINE__, ~ **ppCi, ~10);
                    163:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    164:        iequals(__LINE__, ~ **ppCi, ~10);
                    165:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    166:        iequals(__LINE__, ~ **ppCi, ~10);
                    167:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    168:        iequals(__LINE__, ~ **ppCi, ~10);
                    169:        lequals(__LINE__, ~ Ml(), ~14L);
                    170:        iequals(__LINE__, ~ **ppCi, ~10);
                    171:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    172:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    173:        iequals(__LINE__, ~ Mc(), ~7);
                    174: #if ANSI
                    175:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    176:        iequals(__LINE__, ~ Msc(), ~8);
                    177: #endif
                    178:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    179:        iequals(__LINE__, ~ Ms(), ~9);
                    180:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    181:        iequals(__LINE__, ~ Mi(), ~10);
                    182:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    183:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    184:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    185:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    186:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    187:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    188:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    189:        lequals(__LINE__, ~ Ml(), ~14L);
                    190:        iequals(__LINE__, ~ (int)**ppCuc, ~11);
                    191:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    192:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    193:        iequals(__LINE__, ~ Mc(), ~7);
                    194: #if ANSI
                    195:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    196:        iequals(__LINE__, ~ Msc(), ~8);
                    197: #endif
                    198:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    199:        iequals(__LINE__, ~ Ms(), ~9);
                    200:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    201:        iequals(__LINE__, ~ Mi(), ~10);
                    202:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    203:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    204:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    205:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    206:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    207:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    208:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    209:        lequals(__LINE__, ~ Ml(), ~14L);
                    210:        iequals(__LINE__, ~ (int)**ppCus, ~12);
                    211:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    212:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    213:        iequals(__LINE__, ~ Mc(), ~7);
                    214: #if ANSI
                    215:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    216:        iequals(__LINE__, ~ Msc(), ~8);
                    217: #endif
                    218:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    219:        iequals(__LINE__, ~ Ms(), ~9);
                    220:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    221:        iequals(__LINE__, ~ Mi(), ~10);
                    222:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    223:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    224:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    225:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    226:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    227:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    228:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    229:        lequals(__LINE__, ~ Ml(), ~14L);
                    230:        iequals(__LINE__, ~ (int)**ppCui, ~13);
                    231:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    232:        lequals(__LINE__, ~ **ppCl, ~14L);
                    233:        iequals(__LINE__, ~ Mc(), ~7);
                    234: #if ANSI
                    235:        lequals(__LINE__, ~ **ppCl, ~14L);
                    236:        iequals(__LINE__, ~ Msc(), ~8);
                    237: #endif
                    238:        lequals(__LINE__, ~ **ppCl, ~14L);
                    239:        iequals(__LINE__, ~ Ms(), ~9);
                    240:        lequals(__LINE__, ~ **ppCl, ~14L);
                    241:        iequals(__LINE__, ~ Mi(), ~10);
                    242:        lequals(__LINE__, ~ **ppCl, ~14L);
                    243:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    244:        lequals(__LINE__, ~ **ppCl, ~14L);
                    245:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    246:        lequals(__LINE__, ~ **ppCl, ~14L);
                    247:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    248:        lequals(__LINE__, ~ **ppCl, ~14L);
                    249:        lequals(__LINE__, ~ Ml(), ~14L);
                    250:        lequals(__LINE__, ~ **ppCl, ~14L);
                    251:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    252:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    253:        iequals(__LINE__, ~ Mc(), ~7);
                    254: #if ANSI
                    255:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    256:        iequals(__LINE__, ~ Msc(), ~8);
                    257: #endif
                    258:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    259:        iequals(__LINE__, ~ Ms(), ~9);
                    260:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    261:        iequals(__LINE__, ~ Mi(), ~10);
                    262:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    263:        iequals(__LINE__, ~ (int)Muc(), ~11);
                    264:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    265:        iequals(__LINE__, ~ (int)Mus(), ~12);
                    266:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    267:        iequals(__LINE__, ~ (int)Mui(), ~13);
                    268:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    269:        lequals(__LINE__, ~ Ml(), ~14L);
                    270:        lequals(__LINE__, ~ (long)**ppCul, ~15L);
                    271:        lequals(__LINE__, ~ (long)Mul(), ~15L);
                    272:        }}
                    273:        return  report(Filename);
                    274:        }

unix.superglobalmegacorp.com

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