gcc/testsuite/gcc.dg/noncompile/920923-1.c

   1 /* This test case contains a large number of syntactic errors.  We
   2    believe the intent of the test is that the compiler simply not
   3    crash.  The set of error messages reported is different when the C
   4    parser is generated with bison 1.50 than 1.35.  It is not worth
   5    attempting to prevent this.  Instead, we use a single dg-error with
   6    a regexp that will match _all_ the errors indiscriminately.  The
   7    old error/warning/etc markers are kept around for reference, but
   8    disabled.
   9
  10    Revisit after new (recursive descent) parser is implemented for C.
  11    -- zw 2002-10-17  */
  12
  13 /* { dg-error ".*" "many syntax errors" { target *-*-* } 0 } */
  14
  15 typedef BYTE unsigned char;     /* { error "syntax error|empty decl" } */
  16 typedef int item_n;
  17 typedef int perm_set;
  18 struct PENT { caddr_t v_addr; };/* { error "parse error|no semicolon" } */
  19 typedef struct PENT prec;
  20 typedef struct PENT *prec_t;
  21 prec_t mem_hash;
  22 BYTE *mem_base;                 /* { error "parse error|no type" } */
  23 struct PTE {
  24      BYTE *p_page;              /* { error "parse error|no semicolon" } */
  25      perm_set p_perms;
  26 };                              /* { error "parse error" } */
  27 typedef struct PTE pte;
  28 struct PTP {
  29      union {
  30           struct *PTP p_tablep; /* { error "parse error|no semicolon" } */
  31           struct *PTE p_entry;
  32      } u;                       /* { warning "no type or storage class" } */
  33      int valid;
  34 };                              /* { error "parse error" } */
  35 typedef struct PTP (u.p_tablep);/* { error "parse error" } */
  36 int pfree=0;
  37 int pcount=0;
  38
  39 void
  40 mmu_walk_find(va)
  41 caddr_t va;                     /* { error "parse error|no type" } */
  42 {
  43      BYTE *page_addr;
  44      if (mmu_base[Level1(va)]->valid==0x0) {
  45           l1_base = mmu_base[Level1(va)]->(u.p_tablep) = p_alloc();
  46           mmu_base[Level1(va)]->valid = 0x3;    /* { error "parse error" } */
  47           for (idx=0; idx<LEVEL1_ENTRIES; idx++)
  48                l1_base[idx]->valid = 0x0;
  49           goto build_level2;
  50      } else
  51           l1_base = mmu_base[Level1(va)]->(u.p_tablep);
  52
  53      if (l1_base[Level2(va)]->valid==0x0) {
  54      build_level2:
  55           l2_base = l1_base[Level2(va)]->(u.p_tablep) = p_alloc();
  56           l1_base[Level2(va)]->valid = 0x3;     /* { error "parse error" } */
  57           for (idx=0; idx<LEVEL2_ENTRIES; idx++)
  58                l2_base[idx]->valid=0x0;
  59           goto build_page;
  60      } else
  61           l2_base = mmu_base[Level2(va)]->(u.p_tablep);
  62
  63      page_addr = l2_base[Level2(va)]->valid;/* { error "undeclared|no type" } */
  64 }                               /* { error "parse error" } */
  65
  66 void *
  67 a_translate(va_op, v_addr)
  68 int va_op;
  69 caddr_t v_addr;                 /* { error "parse error" } */
  70 {
  71      register prec_t bucket;
  72      register caddr_t p_addr;   /* { error "syntax error" } */
  73      bucket = mem_hash+((((v_addr)>>ITEMBITS))&hash_mask); /* { error "undeclared|for each function" } */
  74      do {
  75           if (bucket->v_addr == ((v_addr)>>ITEMBITS) {  /* { error "incomplete type|parse error" } */
  76                if(!(bucket->perm_set&va_op))
  77                     goto prot_fault;
  78                return mem_base + v_addr;
  79           }
  80      } while((bucket++)->v_addr != ((caddr_t)0));  /* { error "parse error" } */
  81
  82  page_miss:
  83      p_addr = (--bucket)->p_addr;       /* { error "undeclared|pointer to" } */
  84  page_type:
  85      switch (p_addr) {
  86      case BUCKET_FULL:          /* { error "undeclared" } */
  87           enlarge_hash_table(mem_hash);
  88      case((caddr_t)0):          /* { error "undeclared|parse error" } */
  89           p_addr = fill_item_entry(va_op, v_addr);
  90           goto page_type;
  91      case((caddr_t)1):          /* { error "parse error" } */
  92      default:
  93           ((void)(((0))?0:(__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
  94                                      "FALSE", 327, "b.c"), 0)));
  95      }
  96 }
  97
  98 void
  99 flush_hash(hasht, hash_size)
 100 prec_t hasht;
 101 int hash_size;
 102 {
 103      register prec_t bucket;
 104      register int idx;
 105      bucket = hasht;
 106      for(idx=(hash_size*3)-1; idx>=0; idx--) {
 107           bucket->v_addr = ((caddr_t)0);/* { error "undeclared|pointer to|parse error" } */
 108           bucket->p_addr = ((caddr_t)0);/* { error "pointer to|parse error" } */
 109           bucket->perm_set = VA_EMPTY;  /* { error "undeclared|pointer to" } */
 110      }
 111 }
 112
 113 extern void *calloc(__SIZE_TYPE__, __SIZE_TYPE__);
 114
 115 void
 116 init_mem()
 117 {
 118      mem_base = (BYTE *) calloc(1024, (1<<13)); /* { error "undeclared|parse error" } */
 119      ((void)((mem_base != (BYTE *)0)    /* { error "parse error" } */
 120              ? 0
 121              : (__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
 122                           "mem_base != (BYTE *)0", 366, "b.c"),
 123                 0)));
 124      hash_num = INIT_NUM_ENTRIES * 3;   /* { error "undeclared" } */
 125      mem_hash = (prec_t) calloc(hash_num, sizeof(prec)); /* { error "incomplete type" } */
 126      ((void)((mem_hash != (prec_t)0)
 127              ? 0
 128              : (__eprintf("Failed assertion`%s'at line%d of`%s'.\n",
 129                           "mem_hash != (prec_t)0", 370, "b.c"),
 130                 0)));
 131      flush_hash(mem_hash, 32);
 132      build_ptables(mem_base, 1024*(1<<13)); /* { bogus "integer overflow" "int smaller than 32 bits" } */
 133 }
 134
 135 struct tm {
 136      int tm_sec; int tm_min; int tm_hour;
 137      int tm_mday;int tm_mon; int tm_year;
 138      int tm_wday;int tm_yday;int tm_isdst;
 139      char*tm_zone; long tm_gmtoff;
 140 };