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 / support.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  5KB  |  286 lines
  1. /*
  2.  * support.c
  3.  * Native language support.
  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. #include "config.h"
  15. #include <assert.h>
  16. #include <stdarg.h>
  17. #include <string.h>
  18. #if defined(HAVE_MALLOC_H)
  19. #include <malloc.h>
  20. #endif
  21. #if defined(HAVE_UNISTD_H)
  22. #include <unistd.h>
  23. #endif
  24. #if defined(HAVE_SYS_TIME_H)
  25. #include <sys/time.h>
  26. #endif
  27. #include "gtypes.h"
  28. #include "access.h"
  29. #include "object.h"
  30. #include "constants.h"
  31. #include "baseClasses.h"
  32. #include "classMethod.h"
  33. #include "lookup.h"
  34. #include "errors.h"
  35. #include "exception.h"
  36. #include "slots.h"
  37. #include "external.h"
  38. #include "machine.h"
  39. #include "support.h"
  40. #include "md.h"
  41.  
  42. #define    MAXEXCEPTIONLEN        200
  43. #define    CONSTRUCTOR_NAME    "<init>"
  44. #define    ERROR_SIGNATURE        "(Ljava/lang/String;)V"
  45.  
  46. /* Anchor point for user defined properties */
  47. userProperty* userProperties;
  48.  
  49. /*
  50.  * Convert an Java String to a C string.
  51.  */
  52. char*
  53. javaString2CString(stringClass* js, char* cs, int len)
  54. {
  55.     if (len == 0) {
  56.         return (0);
  57.     }
  58.     len--;
  59.     if (len > js->count) {
  60.         len = js->count;
  61.     }
  62.     strncpy(cs, STRING_OBJ2DATA(js->value) + js->offset, len);
  63.     cs[len] = 0;
  64.     return (cs);
  65. }
  66.  
  67. /*
  68.  * Convert a C string into a Java String.
  69.  */
  70. stringClass*
  71. makeJavaString(char* cs, int len)
  72. {
  73.     return (getString(STRING_DATA2BASE(addStringLen(cs, len))));
  74. }
  75.  
  76. /*
  77.  * Convert a C string into a Java char array.
  78.  */
  79. object*
  80. makeJavaCharArray(char* cs, int len)
  81. {
  82.     return (STRING_DATA2OBJECT(addStringLen(cs, len)));
  83. }
  84.  
  85. /*
  86.  * Call a Java method from native code.
  87.  */
  88. long
  89. do_execute_java_method(void* ee, object* obj, char* method_name, char* signature, methods* mb, int isStaticCall, ...)
  90. {
  91.     char* sig;
  92.     int args;
  93.     va_list argptr;
  94.  
  95.     if (mb == 0 || mb->ncode == 0) {
  96.         mb = findMethod(obj->dtable->class, addStringPair(method_name, signature));
  97.         if (mb == 0) {
  98.             throwException(NoSuchMethodError);
  99.         }
  100.     }
  101.  
  102.     /* Calculate number of arguments */
  103.     sig = signature;
  104.     args = sizeofSig(&sig);
  105.  
  106.     /* Make the call */
  107.     va_start(argptr, isStaticCall);
  108.      CALL_KAFFE_FUNCTION_VARARGS(mb, obj, args, argptr);
  109.     va_end(argptr);
  110.  
  111.     return (0);
  112. }
  113.  
  114. /*
  115.  * Call a Java static method on a class from native code.
  116.  */
  117. long
  118. do_execute_java_class_method(char* cname, char* method_name, char* signature, ...)
  119. {
  120.     char* sig;
  121.     int args;
  122.     va_list argptr;
  123.     classes* class;
  124.     methods* mb;
  125.  
  126.     /* Convert "." to "/" */
  127.     classname2pathname(cname, cname);
  128.  
  129.     class = lookupClass(addString(cname));
  130.     assert(class != 0);
  131.     mb = findMethod(class, addStringPair(method_name, signature));
  132.     if (mb == 0) {
  133.         throwException(NoSuchMethodError);
  134.     }
  135.  
  136.     /* Calculate number of arguments */
  137.     sig = signature;
  138.     args = sizeofSig(&sig);
  139.  
  140.     /* Make the call */
  141.     va_start(argptr, signature);
  142.      CALL_KAFFE_FUNCTION_VARARGS(mb, 0, args, argptr);
  143.     va_end(argptr);
  144.  
  145.     return (0);
  146. }
  147.  
  148. /*
  149.  * Allocate and object and execute the constructor.
  150.  */
  151. object*
  152. execute_java_constructor(void* ee, char* cname, classes* cc, char* signature, ...)
  153. {
  154.     int args;
  155.     object* obj;
  156.     char* sig;
  157.     va_list argptr;
  158.     methods* mb;
  159.     char buf[MAXEXCEPTIONLEN];
  160.  
  161.     if (cc == 0) {
  162.         /* Convert "." to "/" */
  163.         classname2pathname(cname, buf);
  164.  
  165.         cc = lookupClass(addString(buf));
  166.         assert(cc != 0);
  167.     }
  168.  
  169.     mb = findMethod(cc, addStringPair(CONSTRUCTOR_NAME, signature));
  170.     if (mb == 0) {
  171.         throwException(NoSuchMethodError);
  172.     }
  173.  
  174.     obj = alloc_object(cc, false);
  175.     assert(obj != 0);
  176.  
  177.     /* Calculate number of arguments */
  178.     sig = signature;
  179.     args = sizeofSig(&sig);
  180.  
  181.     /* Make the call */
  182.     va_start(argptr, signature);
  183.      CALL_KAFFE_FUNCTION_VARARGS(mb, obj, args, argptr);
  184.     va_end(argptr);
  185.  
  186.     return (obj);
  187. }
  188.  
  189.  
  190. /*
  191.  * Signal an error by creating the object and throwing the exception.
  192.  */
  193. void
  194. SignalError(void* ee, char* cname, char* str)
  195. {
  196.     object* obj;
  197.  
  198.     obj = execute_java_constructor(ee, cname, 0, ERROR_SIGNATURE, makeJavaString(str, strlen(str)));
  199.     throwException(obj);
  200. }
  201.  
  202. /*
  203.  * Convert a class name to a path name.
  204.  */
  205. void
  206. classname2pathname(char* from, char* to)
  207. {
  208.     int i;
  209.  
  210.     /* Convert any '.' in name to '/' */
  211.     for (i = 0; from[i] != 0; i++) {
  212.         if (from[i] == '.') {
  213.             to[i] = '/';
  214.         }
  215.         else {
  216.             to[i] = from[i];
  217.         }
  218.     }
  219.     to[i] = 0;
  220. }
  221.  
  222. /*
  223.  * Return current time in milliseconds.
  224.  */
  225. jlong
  226. currentTime(void)
  227. {
  228.     jlong tme;
  229. #if !defined(HAVE_NATIVE_INT64)
  230.     tme.jl = 0;
  231.     tme.jh = 0;
  232. #elif defined(HAVE_GETTIMEOFDAY)
  233.     struct timeval tm;
  234.     gettimeofday(&tm, 0);
  235.     tme = (((jlong)tm.tv_sec * (jlong)1000) + ((jlong)tm.tv_usec / (jlong)1000));
  236. #else
  237.     tme = 0;
  238. #endif
  239.     return (tme);
  240. }
  241.  
  242. /*
  243.  * Set a property to a value.
  244.  */
  245. void
  246. setProperty(void* properties, char* key, char* value)
  247. {
  248.     do_execute_java_method(0, properties, "put",
  249.         "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
  250.         0, false,
  251.         makeJavaString(key, strlen(key)),
  252.         makeJavaString(value, strlen(value)));
  253. }
  254.  
  255. /*
  256.  * Allocate a new object of the given class name.
  257.  */
  258. object*
  259. AllocObject(char* classname)
  260. {
  261.     classes* class;
  262.  
  263.     class = lookupClass(classname);
  264.     assert(class != 0);
  265.  
  266.     return (alloc_object(class, false));
  267. }
  268.  
  269. /*
  270.  * Allocate a new array of a given size and type.
  271.  */
  272. object*
  273. AllocArray(int sz, int type)
  274. {
  275.     return (alloc_array(sz, type));
  276. }
  277.  
  278. /*
  279.  * Allocate a new array of the given size and class name.
  280.  */
  281. object*
  282. AllocObjectArray(int sz, char* classname)
  283. {
  284.     return (alloc_objectarray(sz, classname));
  285. }
  286.