home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / kaffe-0.5p4-src.tgz / tar.out / contrib / kaffe / kaffevm / baseClasses.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  5KB  |  248 lines
  1. /*
  2.  * baseClasses.c
  3.  * Handle base classes.
  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    DBG(s)
  15.  
  16. #include "config.h"
  17. #include <stdio.h>
  18. #include <stdlib.h>
  19. #include <assert.h>
  20. #include <string.h>
  21. #include <stdarg.h>
  22. #if defined(HAVE_MALLOC_H)
  23. #include <malloc.h>
  24. #endif
  25. #include "gtypes.h"
  26. #include "access.h"
  27. #include "object.h"
  28. #include "constants.h"
  29. #include "classMethod.h"
  30. #include "baseClasses.h"
  31. #include "lookup.h"
  32. #include "slots.h"
  33. #include "external.h"
  34. #include "machine.h"
  35. #include "md.h"
  36.  
  37. char* ObjectClassName;
  38. strpair* initpair;
  39. strpair* finalpair;
  40.  
  41. classes* StringClass;
  42. classes* ClassClass;
  43. classes* ObjectClass;
  44. classes* CloneableClass;
  45. classes* CharArrayClass;
  46.  
  47. classes* classInitHead;
  48.  
  49. int classInitLevel = 2;
  50.  
  51. #define    INIT        "<clinit>"
  52. #define    INITSIG        "()V"
  53. #define    FINAL        "finalize"
  54. #define    FINALSIG    "()V"
  55.  
  56. /* Initialisation prototypes */
  57. void initClasspath(void);
  58. void initExceptions(void);
  59. void initNative(void);
  60. void initThreads(void);
  61. void initTypes(void);
  62.  
  63. /*
  64.  * Initialise the machine.
  65.  */
  66. void
  67. initialise(void)
  68. {
  69.     /* Setup garbage collection system */
  70.     initGc();
  71.  
  72.     /* Setup CLASSPATH */
  73.     initClasspath();
  74.  
  75.     /* Create the initialise launch pair */
  76.     initpair = addStringPair(INIT, INITSIG);
  77.  
  78.     /* Create the finalize launch pair */
  79.     finalpair = addStringPair(FINAL, FINALSIG);
  80.  
  81.     /* Read in base classes */
  82.     initBaseClasses();
  83.  
  84.     /* Setup exceptions */
  85.     initExceptions();
  86.  
  87.     /* Init native support */
  88.     initNative();
  89.  
  90.     /* Init thread support */
  91.     initThreads();
  92. }
  93.  
  94. /*
  95.  * We need to use certain classes in the internal machine so we better
  96.  * get them in now in a known way so we can refer back to them.
  97.  * Currently we need java/lang/Object, java/lang/Class and java/lang/String.
  98.  */
  99. void
  100. initBaseClasses(void)
  101. {
  102.     /* Start with the simple types. */
  103.     initTypes();
  104.  
  105.     /* Read in object */
  106.     ObjectClassName = addString(OBJECTCLASS);
  107.     ObjectClass = lookupClass(ObjectClassName);
  108.     if (ObjectClass == 0) {
  109.         fprintf(stderr, "Failed to find class %s ... aborting.\n", OBJECTCLASS);
  110.         exit(1);
  111.     }
  112.  
  113.     /* Read in class */
  114.     ClassClass = lookupClass(addString(CLASSCLASS));
  115.     if (ClassClass == 0) {
  116.         fprintf(stderr, "Failed to find class %s ... aborting.\n", CLASSCLASS);
  117.         exit(1);
  118.     }
  119.  
  120.     /* Fixup mtable because it couldn't be made for the first classes */
  121.     ClassClass->head.dtable = ClassClass->dtable;
  122.     ObjectClass->head.dtable = ClassClass->dtable;
  123.  
  124.     /* Read in strings */
  125.     StringClass = lookupClass(addString(STRINGCLASS));
  126.     if (StringClass == 0) {
  127.         fprintf(stderr, "Failed to find class %s ... aborting.\n", STRINGCLASS);
  128.         exit(1);
  129.     }
  130.  
  131.     /* Read in clonable class */
  132.     CloneableClass = lookupClass(addString(CLONEABLECLASS));
  133.     if (CloneableClass == 0) {
  134.         fprintf(stderr, "Failed to find class %s ... aborting.\n", CLONEABLECLASS);
  135.         exit(1);
  136.     }
  137.  
  138.     /* Create char array class */
  139.     CharArrayClass = lookupArray("[C");
  140.     if (CharArrayClass == 0) {
  141.         fprintf(stderr, "Failed to find class %s ... aborting.\n", "[C");
  142.         exit(1);
  143.     }
  144.  
  145.     initClasses();
  146. }
  147.  
  148. /*
  149.  * Creata a string in the string cache.
  150.  */
  151. char*
  152. addStringLen(char* s, int len)
  153. {
  154.     strconst* m;
  155.  
  156.     m = malloc(sizeof(strconst) + len + 1);
  157.     strncpy(m->data, s, len);
  158.     m->data[len] = 0;
  159.     return (addStringConstant(m));
  160. }
  161.  
  162. /*
  163.  * Create a string pair in the string pair cache.
  164.  */
  165. strpair*
  166. addStringPair(char* s1, char* s2)
  167. {
  168.     strpair* pair;
  169.  
  170.     pair = addStringConstantPair(addString(s1), addString(s2));
  171.     assert(pair != 0);
  172.  
  173.     return (pair);
  174. }
  175.  
  176. /*
  177.  * We translate a CONSTANT_Chararray to a CONSTANT_String on demand.
  178.  * The strings in the .class file are not held as real objects, so
  179.  * we convert them here.
  180.  */
  181. slots*
  182. makeStringObject(int idx, constants* pool)
  183. {
  184.     stringClass* obj;
  185.  
  186.     assert(pool->tags[idx] == CONSTANT_Chararray);
  187.  
  188.     obj = getString(STRING_DATA2BASE(pool->data[STRING_NAME(idx, pool)].v.tstr));
  189.  
  190.     /* Install new object */
  191.     pool->tags[idx] = CONSTANT_String;
  192.     pool->data[idx].v.taddr = obj;
  193.  
  194.     return (&pool->data[idx]);
  195. }
  196.  
  197. /*
  198.  * Convert a strconst to a String object.
  199.  */
  200. stringClass*
  201. getString(strconst* str)
  202. {
  203.     stringClass* obj;
  204.  
  205.     if (str->string == 0) {
  206.         obj = (stringClass*)alloc_object(StringClass, true);
  207.         assert(obj != 0);
  208.  
  209.         obj->value = &str->obj;
  210.         obj->offset = 0;                /* ??? */
  211.         obj->count = obj->value->size;            /* ??? */
  212.         str->string = obj;
  213.     }
  214.     return (str->string);
  215. }
  216.  
  217. /*
  218.  * Initialise classes.
  219.  */
  220. void
  221. initClasses(void)
  222. {
  223.     classes* class;
  224.     classes* nclass;
  225.     methods* meth;
  226.  
  227.     classInitLevel++;
  228.  
  229.     class = classInitHead;
  230.     classInitHead = 0;
  231.     while (class != 0) {
  232.         class->state = CSTATE_OK;
  233.  
  234.         meth = findMethod(class, initpair);
  235.         assert(meth != 0);
  236. DBG(        printf("Initialising %s static %d\n", class->name, class->sfsize); fflush(stdout); )
  237.         CALL_KAFFE_FUNCTION(meth, 0);
  238.         nclass = class->nextInit;
  239.         class->nextInit = 0;
  240.         class->prevInit = 0;
  241.         class = nclass;
  242.     }
  243.  
  244.     classInitLevel--;
  245.     /* We should never drop below our initial level of two */
  246.     assert(classInitLevel >= 2);
  247. }
  248.