void
java_lang_VMClass_initialize(struct Hjava_lang_Class* c)
{
	errorInfo einfo;

	if (processClass(c, CSTATE_COMPLETE, &einfo) == false) {
		throwError(&einfo);
	}
}
Пример #2
0
/**
 * Allocate an object and execute the constructor.
 *
 * @param cname the name of the class to be instantiated (may be 0 if cc is != 0)
 * @param loader the class loader that's to be used to lookup the class
 * @param cc the class to be instantiated (may be 0 if cname is != 0)
 * @param signature the signature of the constructor to be executed
 * @param argptr arguments to be passed to the constructor
 *
 * @throws InstantiationException if class is an interface or abstract
 * @throws NoSuchMethodError if the specified constructor cannot be found
 *
 * @return the newly allocated object
 */
Hjava_lang_Object*
execute_java_constructor_v(const char* cname, Hjava_lang_ClassLoader* loader,
	Hjava_lang_Class* cc, const char* signature, va_list argptr)
{
	Hjava_lang_Object* obj;
	Method* mb;
	jvalue retval;
	errorInfo info;
	Utf8Const* sig;

	if (cc == 0) {
		char *buf;

		/* Convert "." to "/" and lookup class */
		buf = checkPtr(KMALLOC(strlen(cname) + 1));
		classname2pathname(cname, buf);
		cc = lookupClass(buf, loader, &info);
		KFREE(buf);
		if (!cc) {
			throwError(&info);
		}
	}

	/* We cannot construct interfaces or abstract classes */
	if (CLASS_IS_INTERFACE(cc) || CLASS_IS_ABSTRACT(cc)) {
		throwException(InstantiationException(cc->name->data));
	}

	if (cc->state < CSTATE_USABLE) {
		if (processClass(cc, CSTATE_COMPLETE, &info) == false) {
			throwError(&info);
		}
	}

	sig = checkPtr(utf8ConstFromString(signature));
	mb = findMethodLocal(cc, constructor_name, sig);
	utf8ConstRelease(sig);
	if (mb == 0) {
		throwException(NoSuchMethodError(constructor_name->data));
	}

	obj = newObject(cc);
	assert(obj != 0);

	/* Make the call */
	KaffeVM_callMethodV(mb, METHOD_NATIVECODE(mb), obj, argptr, &retval);

	return (obj);
}
Пример #3
0
static void findTag (tokenInfo *const token)
{
	if (currentContext->kind != K_UNDEFINED)
	{
		/* Drop context, but only if an end token is found */
		dropContext (token);
	}

	if (token->kind == K_CONSTANT && vStringItem (token->name, 0) == '`')
	{
		/* Bug #961001: Verilog compiler directives are line-based. */
		int c = skipWhite (vGetc ());
		readIdentifier (token, c);
		createTag (token);
		/* Skip the rest of the line. */
		do {
			c = vGetc();
		} while (c != EOF && c != '\n');
		vUngetc (c);
	}
	else if (token->kind == K_BLOCK)
	{
		/* Process begin..end blocks */
		processBlock (token);
	}
	else if (token->kind == K_FUNCTION || token->kind == K_TASK)
	{
		/* Functions are treated differently because they may also include the
		 * type of the return value.
		 * Tasks are treated in the same way, although not having a return
		 * value.*/
		processFunction (token);
	}
	else if (token->kind == K_ASSERTION)
	{
		if (vStringLength (currentContext->blockName) > 0)
		{
			vStringCopy (token->name, currentContext->blockName);
			createTag (token);
			skipToSemiColon ();
		}
	}
	else if (token->kind == K_TYPEDEF)
	{
		processTypedef (token);
	}
	else if (token->kind == K_CLASS)
	{
		processClass (token);
	}
	else if (token->kind == K_IGNORE && isSingleStatement (token))
	{
		currentContext->singleStat = TRUE;
	}
	else if (isVariable (token))
	{
		int c = skipWhite (vGetc ());

		tagNameList (token, c);
	}
	else if (token->kind != K_UNDEFINED && token->kind != K_IGNORE)
	{
		int c = skipWhite (vGetc ());

		if (isIdentifierCharacter (c))
		{
			readIdentifier (token, c);
			while (getKind (token) == K_IGNORE)
			{
				c = skipWhite (vGetc ());
				readIdentifier (token, c);
			}
			createTag (token);

			/* Get port list if required */
			c = skipWhite (vGetc ());
			if (c == '(' && hasSimplePortList (token))
			{
				processPortList (c);
			}
			else
			{
				vUngetc (c);
			}
		}
	}
}
/*
 * Convert string name to class object.
 */
struct Hjava_lang_Class*
java_lang_VMClass_forName0(struct Hjava_lang_String* str, struct Hjava_lang_ClassLoader* loader)
{
	errorInfo einfo;
	Hjava_lang_Class* clazz;
	Utf8Const *utf8buf;
	const char *buf;
	int jlen;
	jchar *js;

	/*
	 * NB: internally, we store class names as path names (with slashes
	 *     instead of dots.  However, we must also prevent calls to
	 *     "java/lang/Object" or "[[Ljava/lang/Object;" from succeeding.
	 *	Since class names cannot have slashes, we reject all attempts
	 *	to look up names that do.  Awkward.  Inefficient.
	 */
	js = STRING_DATA(str);
	jlen = STRING_SIZE(str);
	while (--jlen > 0) {
		if (*js++ == '/') {
			postExceptionMessage(&einfo,
				JAVA_LANG(ClassNotFoundException),
				"Cannot have slashes - use dots instead.");
			throwError(&einfo);
		}
	}

	/*
	 * Note the following oddity:
	 *
	 * It is apparently perfectly legal to call forName for array types,
	 * such as "[Ljava.lang.String;" or "[B".
	 * However, it is wrong to call Class.forName("Ljava.lang.String;")
	 *
	 * This situation is similar to the constant pool resolution.  We
	 * therefore do the same thing as in getClass in kaffevm/lookup.c,
	 * that is, use either loadArray or loadClass depending on the name.
	 *
	 * This is somewhat described in Section 5.1.3 of the VM
	 * Specification, titled "Array Classes".  This section seems to
	 * imply that we must avoid asking a class loader to resolve such
	 * array names (those starting with an [), and this is what calling
	 * loadArray does.
	 */

	/* Convert string to utf8, converting '.' to '/' */
	utf8buf = checkPtr(stringJava2Utf8ConstReplace(str, '.', '/'));
	buf = utf8buf->data;

	if (buf[0] == '[') {
		clazz = loadArray(utf8buf, loader, &einfo);
	}
	else {
		clazz = loadClass(utf8buf, loader, &einfo);
	}
	
	/* if an error occurred, throw an exception */
	if (clazz == 0) {
		utf8ConstRelease(utf8buf);
		throwError(&einfo);
	}
	utf8ConstRelease(utf8buf);
	/*
	 * loadClass returns the class in state CSTATE_LINKED.
	 *
	 * Processing to CSTATE_COMPLETE will initialize the class, resolve
	 * its constants and run its static initializers.
	 *
	 * The option to load a class via forName without initializing it
	 * was introduced in 1.2, presumably for the convenience of
	 * programs such as stub compilers.
	 */
	if (processClass(clazz, CSTATE_COMPLETE, &einfo) == false) {
		throwError(&einfo);
	}
	return (clazz);
}
Пример #5
0
void AdaptJClassLoad(JNIEnv *env_id, const char *name, const char *src_name,
                    jint num_interfaces, jint num_methods, JVMPI_Method *methods,
                    jint num_static_fields, JVMPI_Field *statics,
                    int num_instance_fields, JVMPI_Field *instances,
                    jobjectID class_id, jint requested) {
    AdaptJEvent eventID;
    byte *byteBuff;
    byte *b;
    size_t bLength = 0;
    size_t buffSize; /* Computed buffer size for malloc() */
    size_t tmpLen;
    jint i;
    jshort s;
    
    processClass(name, num_methods, methods, class_id);
    s = eventInfo[ADAPTJ_CLASS_LOAD];

    /* Calculate buffer size */
    buffSize = 1;
    if (s & ADAPTJ_FIELD_ENV_ID) {
        buffSize += 4;
    }
    if (s & ADAPTJ_FIELD_CLASS_NAME) {
        buffSize += strlen(name) + 2;
    }
    if (s & ADAPTJ_FIELD_SOURCE_NAME) {
        if (src_name == NULL) {
            src_name = "(null)";
        }
        buffSize += strlen(src_name) + 2;
    }
    if (s & ADAPTJ_FIELD_NUM_INTERFACES) {
        buffSize += 4;
    }
    if ((s & ADAPTJ_FIELD_NUM_METHODS) || (s & ADAPTJ_FIELD_METHODS)) {
        buffSize += 4;
    }
    if (s & ADAPTJ_FIELD_METHODS) {
        for (i = 0; i < num_methods; i++) {
            buffSize += strlen(methods[i].method_name) + 2;
            buffSize += strlen(methods[i].method_signature) + 2;
            buffSize += 12;
        }
    }
    if ((s & ADAPTJ_FIELD_NUM_STATIC_FIELDS) || (s & ADAPTJ_FIELD_STATICS)) {
        buffSize += 4;
    }
    if (s & ADAPTJ_FIELD_STATICS) {
        for (i = 0; i < num_static_fields; i++) {
            buffSize += strlen(statics[i].field_name) + 2;
            buffSize += strlen(statics[i].field_signature) + 2;
        }
    }
    if ((s & ADAPTJ_FIELD_NUM_INSTANCE_FIELDS) || (s & ADAPTJ_FIELD_INSTANCES)) {
        buffSize += 4;
    }
    if (s & ADAPTJ_FIELD_INSTANCES) {
        for (i = 0; i < num_instance_fields; i++) {
            buffSize += strlen(instances[i].field_name) + 2;
            buffSize += strlen(instances[i].field_signature) + 2;
        }
    }
    if (s & ADAPTJ_FIELD_CLASS_LOAD_CLASS_ID) {
        buffSize += 4;
    }
    
    /* Allocate buffer */
    byteBuff = (byte *) malloc(buffSize);
    b = byteBuff;

    /* Write Data to Buffer */
    eventID = ADAPTJ_CLASS_LOAD;
    if (requested) {
        eventID |= ADAPTJ_REQUESTED_EVENT;
    }
    ADAPTJ_WRITE_BYTE(((byte)eventID), b, bLength);
    if (s & ADAPTJ_FIELD_ENV_ID) {
        ADAPTJ_WRITE_JINT(((jint)env_id), b, bLength);
    }
    if (s & ADAPTJ_FIELD_CLASS_NAME) {
        tmpLen = strlen(name);
        ADAPTJ_WRITE_UTF8(name, tmpLen, b, bLength);
    }
    if (s & ADAPTJ_FIELD_SOURCE_NAME) {
        tmpLen = strlen(src_name);
        ADAPTJ_WRITE_UTF8(src_name, tmpLen, b, bLength);
    }
    if (s & ADAPTJ_FIELD_NUM_INTERFACES) {
        ADAPTJ_WRITE_JINT(num_interfaces, b, bLength);
    }
    /* FIXME no interfaces array?? */
    if ((s & ADAPTJ_FIELD_NUM_METHODS) || (s & ADAPTJ_FIELD_METHODS)) {
        ADAPTJ_WRITE_JINT(num_methods, b, bLength);
    }
    
    if (s & ADAPTJ_FIELD_METHODS) {
        for (i = 0; i < num_methods; i++) {
            tmpLen = strlen(methods[i].method_name);
            ADAPTJ_WRITE_UTF8(methods[i].method_name, tmpLen, b, bLength);
            tmpLen = strlen(methods[i].method_signature);
            ADAPTJ_WRITE_UTF8(methods[i].method_signature, tmpLen, b, bLength);
            ADAPTJ_WRITE_JINT(methods[i].start_lineno, b, bLength);
            ADAPTJ_WRITE_JINT(methods[i].end_lineno, b, bLength);
            ADAPTJ_WRITE_JINT(((jint)methods[i].method_id), b, bLength);            
        }
    }

    if ((s & ADAPTJ_FIELD_NUM_STATIC_FIELDS) || (s & ADAPTJ_FIELD_STATICS)) {
        ADAPTJ_WRITE_JINT(num_static_fields, b, bLength);
    }
    if (s & ADAPTJ_FIELD_STATICS) {
        for (i = 0; i < num_static_fields; i++) {
            tmpLen = strlen(statics[i].field_name);
            ADAPTJ_WRITE_UTF8(statics[i].field_name, tmpLen, b, bLength);
            tmpLen = strlen(statics[i].field_signature);
            ADAPTJ_WRITE_UTF8(statics[i].field_signature, tmpLen, b, bLength);
        }
    }
    if ((s & ADAPTJ_FIELD_NUM_INSTANCE_FIELDS) || (s & ADAPTJ_FIELD_INSTANCES)) {
        ADAPTJ_WRITE_JINT(num_instance_fields, b, bLength);
    }
    if (s & ADAPTJ_FIELD_INSTANCES) {
        for (i = 0; i < num_instance_fields; i++) {
            tmpLen = strlen(instances[i].field_name);
            ADAPTJ_WRITE_UTF8(instances[i].field_name, tmpLen, b, bLength);
            tmpLen = strlen(instances[i].field_signature);
            ADAPTJ_WRITE_UTF8(instances[i].field_signature, tmpLen, b, bLength);
        }
    }
    if (s & ADAPTJ_FIELD_CLASS_LOAD_CLASS_ID) {
        ADAPTJ_WRITE_JINT(((jint)class_id), b, bLength);
    }
    
    fileBytes += bLength;
#ifdef ADAPTJ_WRITE_OUTPUT
    fwrite(byteBuff, 1, bLength, outputFile); 
#endif
    free(byteBuff);
}