git.maemo.org Git - opencv/blob - apps/cvenv/EiC/typemod.c

   1 /* typemod%.c
   2  *
   3  *      (C) Copyright Apr 15 1995, Edmond J. Breen.
   4  *                 ALL RIGHTS RESERVED.
   5  * This code may be copied for personal, non-profit use only.
   6  *
   7  * Type Construction
   8  */
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11
  12 #include <stdarg.h>
  13 #include "global.h"
  14 #include "func.h"
  15 #include "xalloc.h"
  16 #include "metric.h"
  17 #include "cdecl.h"
  18
  19 #define crt_type()  (type_expr *) xcalloc(sizeof(type_expr), 1)
  20 #define rtn_type(x) xfree(x)
  21
  22
  23 int EiC_gettype(type_expr * t)
  24 {
  25     if(t)
  26         return t->obj;
  27     else
  28         return -1;
  29 }
  30 void *EiC_getInf(type_expr * t)
  31 {
  32     if(t)
  33         return t->u.inf;
  34     else
  35         return NULL;
  36
  37 }
  38
  39 type_expr *EiC_copytype(type_expr * t)
  40 {
  41     type_expr *copy = NULL, *h;
  42     if (t) {
  43         copy = h = crt_type();
  44         *h = *t;
  45         h->alias = 1;
  46         t = t->nxt;
  47         while (t) {
  48             h->nxt = crt_type();
  49             h = h->nxt;
  50             *h = *t;
  51             h->alias = 1;
  52             t = t->nxt;
  53         }
  54     }
  55     return copy;
  56 }
  57
  58 type_expr *EiC_copyBaseType(type_expr * t)
  59 {
  60     type_expr *copy = NULL, *h;
  61     while(t && !t->base)
  62         t = t->nxt;
  63     if (t) {
  64         copy = h = crt_type();
  65         *h = *t;
  66         h->alias = 1;
  67         t = t->nxt;
  68         while (t) {
  69             h->nxt = crt_type();
  70             h = h->nxt;
  71             *h = *t;
  72             h->alias = 1;
  73             t = t->nxt;
  74         }
  75     }
  76     return copy;
  77 }
  78
  79 type_expr *EiC_transtype(type_expr * t)
  80 {
  81     type_expr *copy = NULL, *h;
  82     if (t) {
  83         copy = h = crt_type();
  84         *h = *t;
  85         t = t->nxt;
  86         while (t) {
  87             h->nxt = crt_type();
  88             h = h->nxt;
  89             *h = *t;
  90             t = t->nxt;
  91         }
  92     }
  93     return copy;
  94 }
  95
  96 type_expr *EiC_addtype(unsigned obj, type_expr * t)
  97 {
  98   extern int EiC_ptrSafe;
  99   type_expr *new;
 100   new = crt_type();
 101   if (new) {
 102     new->obj = obj;
 103     new->nxt = t;
 104   }
 105   if(obj == t_pointer) {
 106     if(EiC_ptrSafe)
 107       setSafe(new);
 108     else
 109       setUnSafe(new);
 110   }
 111   return new;
 112 }
 113
 114 type_expr *EiC_catTypes(type_expr *t1, type_expr * t2)
 115 {
 116     type_expr *p;
 117     p = t1;
 118     if(p) {
 119         while(p->nxt)
 120             p = p->nxt;
 121         p->nxt = t2;
 122         return t1;
 123     }
 124     return t2;
 125 }
 126
 127 int compareConst(type_expr * t1, type_expr *t2)
 128 {
 129     while (t1 && t2)
 130         if(!isconst(t1) && isconst(t2))
 131             return 0;
 132         else {
 133             t1 = t1->nxt;
 134             t2 = t2->nxt;
 135         }
 136     return 1;
 137 }
 138
 139 int EiC_compareSafe(type_expr * t1, type_expr *t2)
 140 {
 141     /* compare  Safe  */
 142     while (t1 && t2 && (EiC_gettype(t1) == EiC_gettype(t2)))
 143         if(issafe(t1) != issafe(t2))
 144             return 0;
 145         else {
 146             t1 = t1->nxt;
 147             t2 = t2->nxt;
 148         }
 149     return 1;
 150 }
 151
 152
 153 int EiC_compatibletypes(type_expr *t1, type_expr * t2)
 154 {
 155     /* A weaker version of sametypes */
 156     switch(t1->obj) {
 157     case t_pointer:
 158     case t_array:     /* do pointers & arrays */
 159         if(t2->obj != t_pointer && t2->obj != t_array)
 160             break;
 161         if (t1->obj == t_pointer && t2->obj == t_pointer)
 162             if (t1->nxt->obj == t_void ||
 163                 t2->nxt->obj == t_void)
 164                 return 1;
 165         return EiC_sametypes(t1->nxt, t2->nxt);
 166     }
 167     return EiC_sametypes(t1,t2);
 168 }
 169
 170 int EiC_sametypes(type_expr * t1, type_expr * t2)
 171 {
 172     int i;
 173     switch(t1->obj) {
 174     case t_struct:      /* do structures */
 175         if (t2->obj != t_struct)
 176             return 0;
 177         else {
 178             struct_t *s1, *s2;
 179             s1 = (struct_t *) EiC_getInf(t1);
 180             s2 = (struct_t *) EiC_getInf(t2);
 181             if(s1 == s2)
 182                 return 1;
 183             else if (s1->n != s2->n)
 184                 return 0;
 185             else {
 186                 for (i = 0; i < s1->n; i++) {
 187                     if (!EiC_sametypes(s1->type[i], s2->type[i]))
 188                         return 0;
 189                     if(strcmp(s1->id[i],s2->id[i]) != 0)
 190                         return 0;
 191                 }
 192             }
 193         }
 194         return 1;
 195     case t_builtin:
 196     case t_func:
 197     case t_funcdec:  /* check functions are compatible */
 198         if(t2->obj != t_func && t2->obj != t_funcdec &&
 199            t2->obj != t_builtin)
 200             break;
 201         return EiC_sameFuncs(t1,t2);
 202     case t_pointer:
 203     case t_array:     /* do pointers & arrays */
 204         if(t2->obj != t1->obj)
 205             break;
 206         if (t1->obj == t_pointer && t2->obj == t_pointer)
 207             if (t1->nxt->obj == t_void ||
 208                 t2->nxt->obj == t_void)
 209                 return 1;
 210         return EiC_sametypes(t1->nxt, t2->nxt);
 211     case t_int:
 212     case t_enum:
 213         if(t2->obj == t_int || t2->obj == t_enum)
 214             return 1;
 215
 216     }
 217     while (t1 && t2) {
 218         if (t1->obj != t2->obj)
 219             break;
 220         t1 = t1->nxt;
 221         t2 = t2->nxt;
 222     }
 223     if (t1 != t2)
 224         return 0;
 225     return 1;
 226 }
 227
 228 void EiC_setAsBaseType(type_expr * t)
 229 {
 230     while (t) {
 231         t->base = 1;
 232         t = t->nxt;
 233     }
 234 }
 235
 236 int EiC_bastype(type_expr * t)
 237 {
 238     while (t && t->nxt)
 239         t = t->nxt;
 240     if(t)
 241         return t->obj;
 242     else
 243         return -1;
 244 }
 245 static void *basinf(type_expr * t)
 246 {
 247     while (t && t->nxt)
 248         t = t->nxt;
 249     if(t)
 250         return t->u.inf;
 251     else
 252         return NULL;
 253 }
 254 static char basalias(type_expr * t)
 255 {
 256     while (t && t->nxt)
 257         t = t->nxt;
 258     if(t)
 259         return t->alias;
 260     else
 261         return -1;
 262
 263 }
 264 void EiC_set_bastype(unsigned t, type_expr * typ)
 265 {
 266     while (typ && typ->nxt)
 267         typ = typ->nxt;
 268     if(typ)
 269         typ->obj = t;
 270 }
 271
 272 void EiC_setaliases(type_expr * t, char a)
 273 {
 274     while (t) {
 275         t->alias = a;
 276         t = t->nxt;
 277     }
 278 }
 279
 280 static void free1type(type_expr * type)
 281 {
 282     void EiC_free_func_inf(func_t * f);
 283     void EiC_free_un_mem(type_expr * e);
 284
 285     if (!type->alias) {
 286         int t;
 287         if ((t = EiC_gettype(type)) == t_func || t == t_funcdec
 288             || t== t_builtin)
 289             EiC_free_func_inf(EiC_getInf(type));
 290         else if (t == t_struct || t == t_union)
 291             EiC_free_un_mem(type);
 292     }
 293     rtn_type(type);
 294 }
 295
 296
 297 void *EiC_freetype(type_expr * t)
 298 {
 299     type_expr *f;
 300     if(!t)
 301         return NULL;
 302     if (t)
 303         do {
 304             f = t->nxt;
 305             free1type(t);
 306             t = f;
 307         } while (t);
 308     return NULL;
 309 }
 310
 311 type_expr *EiC_revtype(type_expr * t)
 312 {
 313     /*
 314      * reverse the type list by reversing
 315      * separate-ably the dec-spec and decl
 316      * parts.
 317      *    REM  decl-spec is the base type(s).
 318      */
 319     type_expr *h, *r = NULL;
 320     if (t) {
 321         while (t && !t->base) {
 322             r = EiC_addtype(t->obj, r);
 323             setInf(r,EiC_getInf(t));
 324             r->alias = t->alias;
 325             r->base = t->base;
 326             r->qual = t->qual;
 327             h = t->nxt;
 328             t->alias = 1;
 329             free1type(t);
 330             t = h;
 331         }
 332         if(r) {
 333             h = r;
 334             while(h->nxt)
 335                 h = h->nxt;
 336             h->nxt = t;
 337         } else
 338             r = t;
 339     }
 340     return r;
 341 }
 342
 343
 344
 345 type_expr *EiC_succType(type_expr * t)
 346 {
 347   if (t) {
 348     type_expr *p;
 349     p = t->nxt;
 350     free1type(t);
 351     return p;
 352   }
 353   return t;
 354 }
 355
 356 void EiC_exchtype(int obj, type_expr * t)
 357 {
 358   extern int EiC_ptrSafe;
 359   t->obj = obj;
 360   if(obj == t_pointer) {
 361     if(EiC_ptrSafe)
 362       setSafe(t);
 363     else
 364       setUnSafe(t);
 365   }
 366 }
 367
 368 int EiC_get_sizeof(type_expr * t)
 369 {
 370     switch (EiC_gettype(t)) {
 371       case t_uchar:
 372       case t_char:   return EiC_metric[m_char][0];
 373       case t_short:
 374       case t_ushort: return EiC_metric[m_short][0];
 375       case t_enum:
 376       case t_uint:
 377       case t_int:    return EiC_metric[m_int][0];
 378       case t_long:
 379       case t_ulong:  return EiC_metric[m_long][0];
 380     case t_llong:    return EiC_metric[m_llong][0];
 381       case t_float:  return EiC_metric[m_float][0];
 382       case t_double: return EiC_metric[m_double][0];
 383       case t_lval:   return EiC_get_sizeof(t->nxt);
 384       case t_pointer:
 385         if(isunsafe(t))
 386           return EiC_metric[m_pointer][0];
 387         else
 388           return sizeof(ptr_t);
 389       case t_array:  return EiC_get_sizeof(t->nxt) * getNumElems(t);
 390       case t_struct:
 391       case t_union:  return ((struct_t *) EiC_getInf(t))->tsize;
 392
 393     } return 0;
 394 }
 395
 396 int EiC_get_align(type_expr * t)
 397 {
 398     switch (EiC_gettype(t)) {
 399       case t_uchar:
 400       case t_char:   return EiC_metric[m_char][1];
 401       case t_short:
 402       case t_ushort: return EiC_metric[m_short][1];
 403       case t_uint:
 404       case t_int:    return EiC_metric[m_int][1];
 405       case t_long:
 406       case t_ulong:  return EiC_metric[m_long][1];
 407       case t_llong:    return EiC_metric[m_llong][1];
 408       case t_float:  return EiC_metric[m_float][1];
 409       case t_double: return EiC_metric[m_double][1];
 410       case t_lval:   return EiC_get_align(t->nxt);
 411       case t_pointer:return EiC_metric[m_pointer][1];
 412       case t_array:  return EiC_get_align(t->nxt);
 413       case t_struct:
 414       case t_union:  return ((struct_t *) EiC_getInf(t))->align;
 415     }
 416     return 0;
 417 }
 418
 419 type_expr *EiC_getcontype(type_expr * t1, type_expr * t2)
 420 {
 421     if (t1 == NULL)
 422         return EiC_copytype(t2);
 423     else
 424         return t1;
 425 }
 426
 427
 428
 429
 430
 431
 432
 433
 434
 435
 436