git.sur5r.net Git - cc65/blob - test/val/cq84.c

   1 /*
   2   !!DESCRIPTION!! C-Manual Chapter 8.4: meaning of declarators
   3   !!ORIGIN!!      LCC 4.1 Testsuite
   4   !!LICENCE!!     own, freely distributeable for non-profit. read CPYRIGHT.LCC
   5 */
   6
   7 struct defs {
   8      int cbits;          /* No. of bits per char           */
   9      int ibits;          /*                 int            */
  10      int sbits;          /*                 short          */
  11      int lbits;          /*                 long           */
  12      int ubits;          /*                 unsigned       */
  13      int fbits;          /*                 float          */
  14      int dbits;          /*                 double         */
  15      #ifndef NO_FLOATS
  16         float fprec;        /* Smallest number that can be    */
  17         float dprec;        /* significantly added to 1.      */
  18      #endif
  19      int flgs;           /* Print return codes, by section */
  20      int flgm;           /* Announce machine dependencies  */
  21      int flgd;           /* give explicit diagnostics      */
  22      int flgl;           /* Report local return codes.     */
  23      int rrc;            /* recent return code             */
  24      int crc;            /* Cumulative return code         */
  25      char rfs[8];        /* Return from section            */
  26 };
  27
  28      int lbits;          /*                 long           */
  29      int ubits;          /*                 unsigned       */
  30      int fbits;          /*                 float          */
  31      int dbits;          /*                 double         */
  32      #ifndef NO_FLOATS
  33         float fprec;        /* Smallest number that can be    */
  34         float dprec;        /* significantly added to 1.      */
  35      #endif
  36      int flgs;           /* Print return codes, by section */
  37      int flgm;           /* Announce machine dependencies  */
  38      int flgd;           /* give explicit diagnostics      */
  39      int flgl;           /* Report local return codes.     */
  40      int rrc;            /* recent return code             */
  41      int crc;            /* Cumulative return code         */
  42      char rfs[8];        /* Return from section            */
  43
  44 #ifdef NO_SLOPPY_EXTERN
  45    int *fip(int x);
  46    int array(int a[],int size,int start);
  47    int glork(int x);
  48 #endif
  49
  50 #ifndef NO_OLD_FUNC_DECL
  51 s84(pd0)          /*  8.4 Meaning of declarators   */
  52 struct defs *pd0;
  53 {
  54 #else
  55 int s84(struct defs *pd0){
  56 #endif
  57 #ifndef NO_SLOPPY_EXTERN
  58    int *ip, i, *fip(), (*pfi)(), j, k, array(), glork();
  59 #else
  60    int *ip, i, j, k,(*pfi)();
  61 /*
  62    extern int
  63    *fip(),
  64    array(),
  65    glork();
  66    int *fip(int x);
  67    int array(int a[],int size,int start);
  68 */
  69 #endif
  70    static int x3d[3][5][7];
  71    #ifndef NO_FLOATS
  72    float fa[17], *afp[17], sum;
  73    #else
  74    signed fa[17], *afp[17], sum;
  75    #endif
  76    static char s84er[] = "s84,er%d\n";
  77    static char qs84[8] = "s84    ";
  78    int rc;
  79    char *ps, *pt;
  80    ps = qs84;
  81    pt = pd0->rfs;
  82    rc = 0;
  83    while (*pt++ = *ps++);
  84
  85         /* The more common varieties of declarators have al-
  86         ready been touched upon, some more than others. It
  87         is useful to compare *fip() and (*pfi)().
  88                                                                 */
  89
  90    ip = fip(3);
  91    if(*ip != 3){
  92      if(pd0->flgd != 0) printf(s84er,1);
  93      rc = rc+1;
  94    }
  95
  96    /* kludges */
  97    #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
  98    if(glork(4) != 4){
  99      if(pd0->flgd != 0) printf(s84er,2);
 100      rc = rc+2;
 101    }
 102         #else
 103    pfi = glork;
 104    if((*pfi)(4) != 4){
 105      if(pd0->flgd != 0) printf(s84er,2);
 106      rc = rc+2;
 107    }
 108         #endif
 109
 110         /* Float fa[17] declares an array of floating point
 111         numbers, and *afp[17] declares an array of pointers
 112         to floats.
 113                                                                 */
 114
 115    for(j=0; j<17; j++){
 116      fa[j] = j;
 117      afp[j] = &fa[j];
 118    }
 119
 120    #ifndef NO_FLOATS
 121    sum = 0.;
 122    #else
 123    sum = 0;
 124    #endif
 125    for(j=0; j<17; j++) sum += *afp[j];
 126    if(sum != 136){
 127      if(pd0->flgd != 0) printf(s84er,4);
 128      rc = rc+4;
 129    }
 130
 131         /*  static int x3d[3][5][7] declares a static three
 132         dimensional array of integers, with rank 3x5x7.
 133         In complete detail, x3d is an array of three items;
 134         each item is an array of five arrays, and each of
 135         the latter arrays is an array of seven integers.
 136         Any of the expressions x3d, x3d[i], x3d[i][j],
 137         and x3d[i][j][k] may reasonably appear in an express-
 138         ion. The first three have type "array"; the last has
 139         type int.
 140                                                                 */
 141
 142    for (i=0; i<3; i++)
 143      for (j=0; j<5; j++)
 144        for (k=0; k<7; k++)
 145          x3d[i][j][k] = i*35+j*7+k;
 146
 147    i = 1; j = 2; k = 3;
 148
 149    /* kludges */
 150    #if defined(FORCE_POINTERS) | defined(NO_OLD_FUNC_DECL)
 151    if( array((int*)x3d,105,0)
 152       +array((int*)x3d[i],35,35)
 153    #else
 154    if( array(x3d,105,0)
 155       +array(x3d[i],35,35)
 156    #endif
 157       +array(x3d[i][j],7,49)
 158       +      x3d[i][j][k]-52){
 159       if(pd0->flgd != 0) printf(s84er,8);
 160       rc = rc+8;
 161    }
 162
 163    return rc;
 164 }
 165
 166 #ifndef NO_OLD_FUNC_DECL
 167 array(a,size,start)
 168 int a[],size,start;
 169 #else
 170 int array(int a[],int size,int start)
 171 #endif
 172 {
 173 /*
 174 #ifndef NO_OLD_FUNC_DECL
 175 array(a,size,start)
 176 int a[],
 177 #else
 178 int array(int a[],
 179 #endif
 180 #ifdef NO_TYPELESS_INT
 181 int
 182 #endif
 183 #ifdef NO_TYPELESS_INT
 184 int
 185 #endif
 186
 187 #ifndef NO_OLD_FUNC_DECL
 188 start; {
 189 #else
 190 start){
 191 #endif
 192 */
 193    int i;
 194    for(i=0; i<size; i++)
 195      if(a[i] != i+start) return 1;
 196
 197    return 0;
 198 }
 199 #ifndef NO_OLD_FUNC_DECL
 200 int *fip(x)
 201 int x;
 202 {
 203 #else
 204 int *fip(int x){
 205 #endif
 206    static int y;
 207    y = x;
 208    return &y;
 209 }
 210 #ifndef NO_OLD_FUNC_DECL
 211 glork(x)
 212 int x;
 213 {
 214 #else
 215 int glork(int x){
 216 #endif
 217 return x;}
 218
 219 /*********************************************************************************************
 220  the main loop that launches the sections
 221 *********************************************************************************************/
 222
 223 #ifndef NO_TYPELESS_STRUCT_PTR
 224         int section(int j,struct* pd0){
 225 #else
 226         int section(int j,void* pd0){
 227 #endif
 228         switch(j){
 229                 case 0: return s84(pd0);
 230         }
 231 }
 232
 233 #define cq_sections 1
 234
 235 /*
 236         C REFERENCE MANUAL (main)
 237 */
 238
 239 #ifndef NO_OLD_FUNC_DECL
 240 main(n,args)
 241 int n;
 242 char **args;
 243 {
 244 #else
 245 int main(int n,char **args) {
 246 #endif
 247
 248 int j;
 249 static struct defs d0, *pd0;
 250
 251    d0.flgs = 1;          /* These flags dictate            */
 252    d0.flgm = 1;          /*     the verbosity of           */
 253    d0.flgd = 1;          /*         the program.           */
 254    d0.flgl = 1;
 255
 256    pd0 = &d0;
 257
 258    for (j=0; j<cq_sections; j++) {
 259      d0.rrc=section(j,pd0);
 260      d0.crc=d0.crc+d0.rrc;
 261      if(d0.flgs != 0) printf("Section %s returned %d.\n",d0.rfs,d0.rrc);
 262    }
 263
 264    if(d0.crc == 0) printf("\nNo errors detected.\n");
 265    else printf("\nFailed.\n");
 266
 267    return d0.crc;
 268 }