home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / kaffeh / constants.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  3KB  |  160 lines
  1. /*
  2.  * constants.c
  3.  * Constant management.
  4.  *
  5.  * Copyright (c) 1996 Systems Architecture Research Centre,
  6.  *           City University, London, UK.
  7.  *
  8.  * See the file "license.terms" for information on usage and redistribution
  9.  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  10.  *
  11.  * Written by Tim Wilkinson <tim@sarc.city.ac.uk>, February 1996.
  12.  */
  13.  
  14. #define    RDBG(s)
  15.  
  16. #include <stdio.h>
  17. #include <assert.h>
  18. #include "gtypes.h"
  19. #include "file.h"
  20. #include "constants.h"
  21.  
  22. static strconst* strhash[STRHASHSZ];
  23.  
  24. /*
  25.  * Read in constant pool from opened file.
  26.  */
  27. constants*
  28. readConstantPool(FILE* fp)
  29. {
  30.     constants* info;
  31.     u4* pool;
  32.     u1* tags;
  33.     int i;
  34.     u1 type;
  35.     u2 len;
  36.     strconst* c;
  37.     char* uc;
  38.     u1 d1;
  39.     u2 d2, d2b;
  40.     u4 d4;
  41.  
  42.     info = (constants*)malloc(sizeof(constants));
  43.     if (info == 0) {
  44.         return (0);
  45.     }
  46.  
  47.     readu2(&info->size, fp);
  48. RDBG(    printf("constant_pool_count=%d\n", info->size);    )
  49.  
  50.     /* Allocate space for tags and data */
  51.     pool = (u4*)malloc((sizeof(u4) + sizeof(u1)) * info->size);
  52.     if (pool == 0) {
  53.         return (0);
  54.     }
  55.     tags = (u1*)&pool[info->size];
  56.     info->data = pool;
  57.     info->tags = tags;
  58.  
  59.     pool[0] = 0;
  60.     tags[0] = CONSTANT_Unknown;
  61.     for (i = 1; i < info->size; i++) {
  62.  
  63.         readu1(&type, fp);
  64. RDBG(        printf("Constant type %d\n", type);            )
  65.         tags[i] = type;
  66.  
  67.         if (type == CONSTANT_Utf8) {
  68.             readu2(&len, fp);
  69.             c = (strconst*)malloc(sizeof(strconst) + len + 1);
  70.             if (c == 0) {
  71.                 return (0);
  72.             }
  73.             fread(c->data, len, sizeof(u1), fp);
  74.             c->data[len] = 0;
  75. RDBG(            printf("Utf8=%s\n", c->data);            )
  76.  
  77.             pool[i] = (u4)addStringConstant(c);
  78.         }
  79.         else if (type == CONSTANT_Unicode) {
  80.             abort();
  81.             readu2(&len, fp);
  82.             uc = (u1*)malloc(len * 2 + 1);
  83.             fread(uc, len, sizeof(u2), fp);
  84.             uc[len * 2] = 0;
  85.             abort();
  86.         }
  87.         else switch (type) {
  88.         case CONSTANT_Class:
  89.             readu2(&d2, fp);
  90.             pool[i] = d2;
  91.             break;
  92.  
  93.         case CONSTANT_String:
  94.             readu2(&d2, fp);
  95.             pool[i] = d2;
  96.             tags[i] = CONSTANT_Chararray;
  97.             break;
  98.  
  99.         case CONSTANT_Fieldref:
  100.         case CONSTANT_Methodref:
  101.         case CONSTANT_InterfaceMethodref:
  102.         case CONSTANT_NameAndType:
  103.             readu2(&d2, fp);
  104.             readu2(&d2b, fp);
  105.             pool[i] = (d2b << 16) | d2;
  106.             break;
  107.  
  108.         case CONSTANT_Integer:
  109.         case CONSTANT_Float:
  110.             readu4(&d4, fp);
  111.             pool[i] = d4;
  112.             break;
  113.  
  114.         case CONSTANT_Long:
  115.         case CONSTANT_Double:
  116.             readu4(&d4, fp);
  117.             pool[i] = d4;
  118.             i++;
  119.             readu4(&d4, fp);
  120.             tags[i] = CONSTANT_Unknown;
  121.             pool[i] = d4;
  122.             break;
  123.  
  124.         default:
  125.             fprintf(stderr, "Bad constant %d\n", type);
  126.             return (0);
  127.         }
  128.     }
  129.  
  130.     return (info);
  131. }
  132.  
  133. /*
  134.  * Add a string to the string pool.
  135.  * If already there, free the new one and return the old one.
  136.  */
  137. char*
  138. addStringConstant(strconst* s)
  139. {
  140.     strconst* ptr;
  141.     uint32 hash;
  142.     int i;
  143.  
  144.     for (hash = 0,i = 0; s->data[i] != 0; i++) {
  145.         hash = hash * 33 + s->data[i];
  146.     }
  147.     hash %= STRHASHSZ;
  148.  
  149.     for (ptr = strhash[hash]; ptr != 0; ptr = ptr->next) {
  150.         if (strcmp(ptr->data, s->data) == 0) {
  151.             free(s);
  152.             return (ptr->data);
  153.         }
  154.     }
  155.     s->next = strhash[hash];
  156.     s->string = 0;
  157.     strhash[hash] = s;
  158.     return (s->data);
  159. }
  160.