Changes: Christian Thalinger
- $Id: native.c 2727 2005-06-17 08:11:34Z twisti $
+ $Id: native.c 2788 2005-06-22 16:08:51Z edwin $
*/
/* get classes */
for (i = 0; i < paramcount; i++) {
- if (!resolve_class_from_typedesc(¶mtypes[i], false,
+ if (!resolve_class_from_typedesc(¶mtypes[i], true, false,
(classinfo **) &result->data[i]))
return NULL;
result = builtin_anewarray(excount, class_java_lang_Class);
for (i = 0; i < excount; i++) {
- if (!resolve_classref_or_classinfo(NULL,m->thrownexceptions[i],resolveEager,false,&cls))
+ if (!resolve_classref_or_classinfo(NULL,m->thrownexceptions[i],resolveEager,true,false,&cls))
return NULL; /* exception */
use_class_as_object(cls);
result->data[i] = (java_objectheader *)cls;
{
classinfo *cls;
- if (!resolve_class_from_typedesc(&(m->parseddesc->returntype),false,&cls))
+ if (!resolve_class_from_typedesc(&(m->parseddesc->returntype),true,false,&cls))
return NULL; /* exception */
use_class_as_object(cls);
Changes: Joseph Wenninger
Christian Thalinger
- $Id: Field.c 2629 2005-06-09 21:22:01Z twisti $
+ $Id: Field.c 2788 2005-06-22 16:08:51Z edwin $
*/
if (!desc)
return NULL;
- if (!resolve_class_from_typedesc(desc,false,(classinfo **)&ret))
+ if (!resolve_class_from_typedesc(desc,true,false,(classinfo **)&ret))
return NULL; /* exception */
use_class_as_object((classinfo*)ret);
Changes: Joseph Wenninger
Christian Thalinger
- $Id: VMClass.c 2687 2005-06-14 17:29:18Z twisti $
+ $Id: VMClass.c 2788 2005-06-22 16:08:51Z edwin $
*/
classinfo *inner;
classinfo *outer;
- if (!resolve_classref_or_classinfo(NULL,c->innerclass[i].inner_class,resolveEager,false,&inner))
+ if (!resolve_classref_or_classinfo(NULL,c->innerclass[i].inner_class,resolveEager,false,false,&inner))
return NULL;
- if (!resolve_classref_or_classinfo(NULL,c->innerclass[i].outer_class,resolveEager,false,&inner))
+ if (!resolve_classref_or_classinfo(NULL,c->innerclass[i].outer_class,resolveEager,false,false,&inner))
return NULL;
if ((outer == c) && (notPublicOnly || (inner->flags & ACC_PUBLIC))) {
Changes:
- $Id: helper.c 2496 2005-05-23 08:06:06Z twisti $
+ $Id: helper.c 2788 2005-06-22 16:08:51Z edwin $
*/
/* resolve and load the class */
- if (!resolve_classref(NULL, cr, resolveEager, true, &c)) {
+ if (!resolve_classref(NULL, cr, resolveEager, true, true, &c)) {
java_objectheader *xptr;
java_objectheader *cause;
Authors: Dieter Thuernbeck
- $Id: inline.c 2487 2005-05-20 17:43:27Z twisti $
+ $Id: inline.c 2788 2005-06-22 16:08:51Z edwin $
*/
if (opcode ==JAVA_INVOKEINTERFACE) {
imr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- if (!resolve_classref(m,imr->classref,resolveEager,true,&imrclass)) {
+ if (!resolve_classref(m,imr->classref,resolveEager,true, true,&imrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
} else {
imr = class_getconstant(m->class, i, CONSTANT_Methodref);
- if (!resolve_classref(m,imr->classref,resolveEager,true,&imrclass)) {
+ if (!resolve_classref(m,imr->classref,resolveEager,true, true,&imrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
Changes: Christian Thalinger
- $Id: parseRT.c 2657 2005-06-13 14:14:44Z twisti $
+ $Id: parseRT.c 2788 2005-06-22 16:08:51Z edwin $
*/
classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass)) {
+ if (!resolve_classref(m,fr->classref,resolveEager,true, true,&frclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_Methodref);
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
mr = m->class->cpinfos[i];
/*mr = class_getconstant(m->class, i, CONSTANT_Methodref)*/
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
constant_classref *cr;
classinfo *ci;
cr = (constant_classref *)class_getconstant(m->class, i, CONSTANT_Class);
- resolve_classref(NULL,cr,resolveEager,false,&ci);
+ resolve_classref(NULL,cr,resolveEager,true, false,&ci);
/*** s_count++; look for s_counts for VTA */
/* add marked methods */
CLASSNAME(ci,"NEW : do nothing",RTA_DEBUGr);
classinfo *cls;
cr = (constant_classref*) class_getconstant(m->class, i, CONSTANT_Class);
- resolve_classref(NULL,cr,resolveEager,false,&cls);
+ resolve_classref(NULL,cr,resolveEager,true, false,&cls);
LAZYLOADING(cls)
CLASSNAMEop(cls,RTA_DEBUGr);
Changes: Christian Thalinger
- $Id: parseXTA.c 2657 2005-06-13 14:14:44Z twisti $
+ $Id: parseXTA.c 2788 2005-06-22 16:08:51Z edwin $
*/
classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass)) {
+ if (!resolve_classref(m,fr->classref,resolveEager,true, true,&frclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *frclass;
fr = class_getconstant(m->class, i, CONSTANT_Fieldref);
- if (!resolve_classref(m,fr->classref,resolveEager,true,&frclass)) {
+ if (!resolve_classref(m,fr->classref,resolveEager,true, true,&frclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_Methodref);
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
mr = m->class->cpinfos[i];
/*mr = class_getconstant(m->class, i, CONSTANT_Methodref)*/
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *mrclass;
mr = class_getconstant(m->class, i, CONSTANT_InterfaceMethodref);
- if (!resolve_classref(m,mr->classref,resolveEager,true,&mrclass)) {
+ if (!resolve_classref(m,mr->classref,resolveEager,true, true,&mrclass)) {
log_text("Could not resolve class reference");
assert(0);
}
classinfo *cls;
constant_classref *cr;
cr = (constant_classref *)class_getconstant(m->class, i, CONSTANT_Class);
- resolve_classref(NULL,cr,resolveEager,false,&cls);
+ resolve_classref(NULL,cr,resolveEager,true, false,&cls);
/*** s_count++; look for s_counts for VTA */
/* add marked methods */
CLASSNAME(cls,"NEW : do nothing",XTA_DEBUGr);
constant_classref *cr;
classinfo *cls;
cr = (constant_classref*) class_getconstant(m->class, i, CONSTANT_Class);
- resolve_classref(NULL,cr,resolveEager,false,&cls);
+ resolve_classref(NULL,cr,resolveEager,true, false,&cls);
LAZYLOADING(cls)
CLASSNAMEop(cls,XTA_DEBUGr);
if (cls->classUsed == NOTUSED){
Joseph Wenninger
Christian Thalinger
- $Id: parse.c 2783 2005-06-22 12:05:49Z edwin $
+ $Id: parse.c 2788 2005-06-22 16:08:51Z edwin $
*/
if (!(cr = class_get_classref_multiarray_of(1, compr)))
return NULL;
- if (!resolve_classref(inline_env->method, cr, resolveLazy, true, &c))
+ if (!resolve_classref(inline_env->method, cr, resolveLazy, true, true, &c))
return NULL;
if (c) {
cr = (constant_classref *) class_getconstant(inline_env->method->class, i, CONSTANT_Class);
- if (!resolve_classref(inline_env->method, cr, resolveLazy, true, &c))
+ if (!resolve_classref(inline_env->method, cr, resolveLazy, true, true, &c))
return NULL;
if (c) {
i = code_get_u2(p + 1, inline_env->method);
cr = (constant_classref *) class_getconstant(inline_env->method->class, i, CONSTANT_Class);
- if (!resolve_classref(inline_env->method, cr, resolveLazy, true,
+ if (!resolve_classref(inline_env->method, cr, resolveLazy, true, true,
&c))
return NULL;
i = code_get_u2(p + 1, inline_env->method);
cr = (constant_classref *) class_getconstant(inline_env->method->class, i, CONSTANT_Class);
- if (!resolve_classref(inline_env->method, cr, resolveLazy, true, &c))
+ if (!resolve_classref(inline_env->method, cr, resolveLazy, true, true, &c))
return NULL;
if (cr->name->text[0] == '[') {
i = code_get_u2(p + 1,inline_env->method);
cr = (constant_classref *) class_getconstant(inline_env->method->class, i, CONSTANT_Class);
- if (!resolve_classref(inline_env->method, cr, resolveLazy, true, &c))
+ if (!resolve_classref(inline_env->method, cr, resolveLazy, true, true, &c))
return NULL;
if (cr->name->text[0] == '[') {
Changes: Christian Thalinger
- $Id: typecheck.c 2787 2005-06-22 13:24:19Z edwin $
+ $Id: typecheck.c 2788 2005-06-22 16:08:51Z edwin $
*/
if (rtype != TYPE_VOID) {
if (rtype != dst->type)
TYPECHECK_VERIFYERROR_bool("Return type mismatch in method invocation");
- typeinfo_init_from_typedesc(&(md->returntype),NULL,&(dst->typeinfo));
+ if (!typeinfo_init_from_typedesc(&(md->returntype),NULL,&(dst->typeinfo)))
+ return false;
}
if (callinginit) {
TYPESTACK_COPY(sp,copy);
}
- TYPEINFO_INIT_CLASSREF_OR_CLASSINFO(stack->typeinfo,initclass);
+ if (!typeinfo_init_class(&(stack->typeinfo),initclass))
+ return false;
}
stack = stack->prev;
}
/* replace uninitialized object type in locals */
- typevectorset_init_object(state->localset,ins,initclass,state->numlocals);
+ if (!typevectorset_init_object(state->localset,ins,initclass,state->numlocals))
+ return false;
/* initializing the 'this' reference? */
if (!ins) {
TYPECHECK_INT(state->curstack->prev);
if (state->iptr[-1].opc != ICMD_ACONST)
TYPECHECK_VERIFYERROR_bool("illegal instruction: builtin_newarray without classinfo");
- TYPEINFO_INIT_CLASSREF(dst->typeinfo,state->iptr[-1].val.a);
+ if (!typeinfo_init_class(&(dst->typeinfo),CLASSREF_OR_CLASSINFO(state->iptr[-1].val.a)))
+ return false;
}
else if (ISBUILTIN(BUILTIN_newarray))
{
TYPECHECK_ADR(state->curstack->prev);
if (state->iptr[-1].opc != ICMD_ACONST)
TYPECHECK_VERIFYERROR_bool("illegal instruction: BUILTIN_arraycheckcast without classinfo");
- TYPEINFO_INIT_CLASSREF(dst->typeinfo,state->iptr[-1].val.a);
+ if (!typeinfo_init_class(&(dst->typeinfo),CLASSREF_OR_CLASSINFO(state->iptr[-1].val.a)))
+ return false;
}
else if (ISBUILTIN(BUILTIN_aastore)) {
TYPECHECK_ADR(state->curstack);
if (!TYPEINFO_MAYBE_ARRAY_OF_REFS(state->curstack->prev->typeinfo))
TYPECHECK_VERIFYERROR_bool("illegal instruction: AALOAD on non-reference array");
- typeinfo_init_component(&state->curstack->prev->typeinfo,&dst->typeinfo);
+ if (!typeinfo_init_component(&state->curstack->prev->typeinfo,&dst->typeinfo))
+ return false;
maythrow = true;
break;
/* the result is pushed on the stack */
if (dst->type == TYPE_ADR) {
- typeinfo_init_from_typedesc(uf->fieldref->parseddesc.fd,NULL,&(dst->typeinfo));
+ if (!typeinfo_init_from_typedesc(uf->fieldref->parseddesc.fd,NULL,&(dst->typeinfo)))
+ return false;
}
maythrow = true;
break;
if (cls)
TYPEINFO_INIT_CLASSINFO(dst->typeinfo,cls);
else
- TYPEINFO_INIT_CLASSREF(dst->typeinfo,state->iptr[0].target);
+ if (!typeinfo_init_class(&(dst->typeinfo),CLASSREF_OR_CLASSINFO(state->iptr[0].target)))
+ return false;
maythrow = true;
break;
}
else {
/* XXX do checks in patcher */
- TYPEINFO_INIT_CLASSREF(dst->typeinfo,state->iptr[0].val.a);
+ if (!typeinfo_init_class(&(dst->typeinfo),CLASSREF_OR_CLASSINFO(state->iptr[0].val.a)))
+ return false;
}
}
maythrow = true;
true, /* two word types use two slots */
(td - lset->td), /* skip 'this' pointer */
&state->returntype);
+ if (i == -1)
+ return false;
td += i;
/* variables not used for arguments are initialized to TYPE_VOID */
LOG("Exception handler stacks set.\n");
/* loop while there are still blocks to be checked */
-
do {
TYPECHECK_COUNT(count_iterations);
Authors: Edwin Steiner
- $Id: typeinfo.c 2750 2005-06-20 15:11:47Z edwin $
+ $Id: typeinfo.c 2788 2005-06-22 16:08:51Z edwin $
*/
} while ((vec = vec->alt) != NULL);
}
-void
+bool
typevectorset_init_object(typevector *set,void *ins,
classref_or_classinfo initclass,
int size)
&& TYPEINFO_IS_NEWOBJECT(set->td[i].info)
&& TYPEINFO_NEWOBJECT_INSTRUCTION(set->td[i].info) == ins)
{
- TYPEINFO_INIT_CLASSREF_OR_CLASSINFO(set->td[i].info,initclass);
+ if (!typeinfo_init_class(&(set->td[i].info),initclass))
+ return false;
}
}
}
+ return true;
}
bool
/* if necessary, try to resolve lazily */
if (!resolve_classref_or_classinfo(NULL /* XXX should now method */,
- c,resolveLazy,true,&cls))
+ c,resolveLazy,false,true,&cls))
{
- log_text("XXX could not resolve class reference"); /* XXX */
- assert(0);
return false;
}
return true;
}
-void
+bool
typeinfo_init_from_typedesc(typedesc *desc,u1 *type,typeinfo *info)
{
TYPEINFO_ASSERT(desc);
if (info) {
if (desc->type == TYPE_ADR) {
TYPEINFO_ASSERT(desc->classref);
- TYPEINFO_INIT_CLASSREF(*info,desc->classref);
+ if (!typeinfo_init_class(info,CLASSREF_OR_CLASSINFO(desc->classref)))
+ return false;
}
else {
TYPEINFO_INIT_PRIMITIVE(*info);
}
}
+ return true;
}
-void
+bool
typeinfo_init_from_methoddesc(methoddesc *desc,u1 *typebuf,typeinfo *infobuf,
int buflen,bool twoword,
u1 *returntype,typeinfo *returntypeinfo)
assert(0);
}
- typeinfo_init_from_typedesc(desc->paramtypes + i,typebuf++,infobuf++);
+ if (!typeinfo_init_from_typedesc(desc->paramtypes + i,typebuf++,infobuf++))
+ return false;
if (twoword && (typebuf[-1] == TYPE_LONG || typebuf[-1] == TYPE_DOUBLE)) {
if (++args > buflen) {
/* check returntype */
if (returntype) {
- typeinfo_init_from_typedesc(&(desc->returntype),returntype,returntypeinfo);
+ if (!typeinfo_init_from_typedesc(&(desc->returntype),returntype,returntypeinfo))
+ return false;
}
+
+ return true;
}
-void
+bool
typedescriptor_init_from_typedesc(typedescriptor *td,
typedesc *desc)
{
td->type = desc->type;
if (td->type == TYPE_ADR) {
- TYPEINFO_INIT_CLASSREF(td->info,desc->classref);
+ if (!typeinfo_init_class(&(td->info),CLASSREF_OR_CLASSINFO(desc->classref)))
+ return false;
}
else {
TYPEINFO_INIT_PRIMITIVE(td->info);
}
+ return true;
}
int
assert(0);
}
- typedescriptor_init_from_typedesc(td,desc->paramtypes + i);
+ if (!typedescriptor_init_from_typedesc(td,desc->paramtypes + i))
+ return -1;
td++;
if (twoword && (td[-1].type == TYPE_LONG || td[-1].type == TYPE_DOUBLE)) {
/* check returntype */
if (returntype) {
- typedescriptor_init_from_typedesc(returntype,&(desc->returntype));
+ if (!typedescriptor_init_from_typedesc(returntype,&(desc->returntype)))
+ return -1;
}
return args;
}
-void
+bool
typeinfo_init_component(typeinfo *srcarray,typeinfo *dst)
{
if (TYPEINFO_IS_NULLTYPE(*srcarray)) {
TYPEINFO_INIT_NULLTYPE(*dst);
- return;
+ return true;
}
if (!TYPEINFO_IS_ARRAY(*srcarray)) {
constant_classref *comp;
comp = class_get_classref_component_of(srcarray->typeclass.ref);
- if (comp)
- TYPEINFO_INIT_CLASSREF(*dst,comp);
- else
+ if (comp) {
+ if (!typeinfo_init_class(dst,CLASSREF_OR_CLASSINFO(comp)))
+ return false;
+ }
+ else {
TYPEINFO_INIT_PRIMITIVE(*dst);
+ }
}
else {
vftbl_t *comp;
if (!srcarray->typeclass.cls->linked) {
if (!link_class(srcarray->typeclass.cls)) {
- log_text("XXX could not link class");
- assert(0);
+ return false;
}
}
}
dst->merged = srcarray->merged; /* XXX should we do a deep copy? */
+ return true;
}
void
Authors: Edwin Steiner
- $Id: typeinfo.h 2749 2005-06-20 15:04:31Z edwin $
+ $Id: typeinfo.h 2788 2005-06-22 16:08:51Z edwin $
*/
} \
(info).merged = NULL;} while(0)
-#define TYPEINFO_INIT_CLASSREF(info,c) \
- typeinfo_init_class(&(info),CLASSREF_OR_CLASSINFO(c))
-
-#define TYPEINFO_INIT_CLASSREF_OR_CLASSINFO(info,c) \
- typeinfo_init_class(&(info),c)
-
/* macros for copying types (destinition is not checked or freed) ***********/
/* TYPEINFO_COPY makes a shallow copy, the merged pointer is simply copied. */
void typevectorset_store(typevector *set,int index,int type,typeinfo *info);
void typevectorset_store_retaddr(typevector *set,int index,typeinfo *info);
void typevectorset_store_twoword(typevector *set,int index,int type);
-void typevectorset_init_object(typevector *set,void *ins,classref_or_classinfo initclass,int size);
+bool typevectorset_init_object(typevector *set,void *ins,classref_or_classinfo initclass,int size);
/* vector functions */
bool typevector_separable_from(typevector *a,typevector *b,int size);
/* initialization functions *************************************************/
+/* RETURN VALUE (bool):
+ * true.............ok,
+ * false............an exception has been thrown.
+ *
+ * RETURN VALUE (int):
+ * >= 0.............ok,
+ * -1...............an exception has been thrown.
+ */
bool typeinfo_init_class(typeinfo *info,classref_or_classinfo c);
-void typeinfo_init_component(typeinfo *srcarray,typeinfo *dst);
+bool typeinfo_init_component(typeinfo *srcarray,typeinfo *dst);
-void typeinfo_init_from_typedesc(typedesc *desc,u1 *type,typeinfo *info);
-void typeinfo_init_from_methoddesc(methoddesc *desc,u1 *typebuf,
+bool typeinfo_init_from_typedesc(typedesc *desc,u1 *type,typeinfo *info);
+bool typeinfo_init_from_methoddesc(methoddesc *desc,u1 *typebuf,
typeinfo *infobuf,
int buflen,bool twoword,
u1 *returntype,typeinfo *returntypeinfo);
-void typedescriptor_init_from_typedesc(typedescriptor *td,
+bool typedescriptor_init_from_typedesc(typedescriptor *td,
typedesc *desc);
int typedescriptors_init_from_methoddesc(typedescriptor *td,
methoddesc *desc,
Edwin Steiner
Christian Thalinger
- $Id: linker.c 2728 2005-06-17 08:12:26Z twisti $
+ $Id: linker.c 2788 2005-06-22 16:08:51Z edwin $
*/
/* resolve this super interface */
if (!resolve_classref_or_classinfo(NULL, c->interfaces[i], resolveEager,
- false, &tc))
+ true, false, &tc))
return NULL;
c->interfaces[i].cls = tc;
} else {
/* resolve super class */
- if (!resolve_classref_or_classinfo(NULL, c->super, resolveEager, false,
+ if (!resolve_classref_or_classinfo(NULL, c->super, resolveEager, true, false,
&super))
return NULL;
c->super.cls = super;
continue;
if (!resolve_classref_or_classinfo(NULL,
m->exceptiontable[j].catchtype,
- resolveEager, false,
+ resolveEager, true, false,
&(m->exceptiontable[j].catchtype.cls)))
return NULL;
}
for (j = 0; j < m->thrownexceptionscount; j++)
if (!resolve_classref_or_classinfo(NULL, m->thrownexceptions[j],
- resolveEager, false,
+ resolveEager, true, false,
&(m->thrownexceptions[j].cls)))
return NULL;
}
Changes: Christan Thalinger
- $Id: resolve.c 2784 2005-06-22 12:09:11Z edwin $
+ $Id: resolve.c 2788 2005-06-22 16:08:51Z edwin $
*/
resolve_class_from_name(classinfo *referer,methodinfo *refmethod,
utf *classname,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result)
{
utf_fprint(stderr,referer->name);
fprintf(stderr,",");
utf_fprint(stderr,classname);
- fprintf(stderr,")\n");
+ fprintf(stderr,",%d,%d)\n",(int)checkaccess,(int)link);
#endif
/* lookup if this class has already been loaded */
/* resolve the component type */
if (!resolve_class_from_name(referer,refmethod,
utf_new(utf_ptr,len),
- mode,link,&cls))
+ mode,checkaccess,link,&cls))
return false; /* exception */
if (!cls) {
RESOLVE_ASSERT(mode == resolveLazy);
#endif
/* check access rights of referer to refered class */
- if (!is_accessible_class(referer,cls)) {
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,
- "class is not accessible XXX add message");
+ if (checkaccess && !is_accessible_class(referer,cls)) {
+ int msglen;
+ char *message;
+
+ msglen = utf_strlen(cls->name) + utf_strlen(referer->name) + 100;
+ message = MNEW(char,msglen);
+ strcpy(message,"class is not accessible (");
+ utf_sprint_classname(message+strlen(message),cls->name);
+ strcat(message," from ");
+ utf_sprint_classname(message+strlen(message),referer->name);
+ strcat(message,")");
+ *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
+ MFREE(message,char,msglen);
return false; /* exception */
}
resolve_classref(methodinfo *refmethod,
constant_classref *ref,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result)
{
- return resolve_classref_or_classinfo(refmethod,CLASSREF_OR_CLASSINFO(ref),mode,link,result);
+ return resolve_classref_or_classinfo(refmethod,CLASSREF_OR_CLASSINFO(ref),mode,checkaccess,link,result);
}
bool
resolve_classref_or_classinfo(methodinfo *refmethod,
classref_or_classinfo cls,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result)
{
#ifdef RESOLVE_VERBOSE
fprintf(stderr,"resolve_classref_or_classinfo(");
utf_fprint(stderr,(IS_CLASSREF(cls)) ? cls.ref->name : cls.cls->name);
- fprintf(stderr,",%i,%i)\n",mode,link);
+ fprintf(stderr,",%i,%i,%i)\n",mode,(int)checkaccess,(int)link);
#endif
*result = NULL;
if (IS_CLASSREF(cls)) {
/* we must resolve this reference */
if (!resolve_class_from_name(cls.ref->referer,refmethod,cls.ref->name,
- mode,link,&c))
+ mode,checkaccess,link,&c))
return false; /* exception */
}
else {
}
bool
-resolve_class_from_typedesc(typedesc *d, bool link, classinfo **result)
+resolve_class_from_typedesc(typedesc *d, bool checkaccess, bool link, classinfo **result)
{
classinfo *cls;
#ifdef RESOLVE_VERBOSE
fprintf(stderr,"resolve_class_from_typedesc(");
descriptor_debug_print_typedesc(stderr,d);
- fprintf(stderr,",%i)\n",link);
+ fprintf(stderr,",%i,%i)\n",(int)checkaccess,(int)link);
#endif
if (d->classref) {
/* a reference type */
if (!resolve_classref_or_classinfo(NULL,CLASSREF_OR_CLASSINFO(d->classref),
- resolveEager,link,&cls))
+ resolveEager,checkaccess,link,&cls))
return false; /* exception */
}
else {
*checked = false;
/* first resolve the type if necessary */
- if (!resolve_classref_or_classinfo(refmethod,typeref,mode,true,&type))
+ if (!resolve_classref_or_classinfo(refmethod,typeref,mode,false,true,&type))
return false; /* exception */
if (!type)
return true; /* be lazy */
for (; setp->any; ++setp) {
/* first resolve the set member if necessary */
- if (!resolve_classref_or_classinfo(refmethod,*setp,mode,true,&result))
+ if (!resolve_classref_or_classinfo(refmethod,*setp,mode,false,true,&result))
return false; /* exception */
if (!result)
return true; /* be lazy */
bool
resolve_class(unresolved_class *ref,
resolve_mode_t mode,
+ bool checkaccess,
classinfo **result)
{
classinfo *cls;
/* first we must resolve the class */
if (!resolve_classref(ref->referermethod,
- ref->classref,mode,true,&cls))
+ ref->classref,mode,checkaccess,true,&cls))
{
/* the class reference could not be resolved */
return false; /* exception */
/* first we must resolve the class containg the field */
if (!resolve_class_from_name(referer,ref->referermethod,
- ref->fieldref->classref->name,mode,true,&container))
+ ref->fieldref->classref->name,mode,true,true,&container))
{
/* the class reference could not be resolved */
return false; /* exception */
fprintf(stderr," checking access rights...\n");
#endif
if (!is_accessible_member(referer,declarer,fi->flags)) {
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,
- "field is not accessible XXX add message");
+ int msglen;
+ char *message;
+
+ msglen = utf_strlen(declarer->name) + utf_strlen(fi->name) + utf_strlen(referer->name) + 100;
+ message = MNEW(char,msglen);
+ strcpy(message,"field is not accessible (");
+ utf_sprint_classname(message+strlen(message),declarer);
+ strcat(message,".");
+ utf_sprint(message+strlen(message),fi->name);
+ strcat(message," from ");
+ utf_sprint_classname(message+strlen(message),referer->name);
+ strcat(message,")");
+ *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
+ MFREE(message,char,msglen);
return false; /* exception */
}
#ifdef RESOLVE_VERBOSE
/* first we must resolve the class containg the method */
if (!resolve_class_from_name(referer,ref->referermethod,
- ref->methodref->classref->name,mode,true,&container))
+ ref->methodref->classref->name,mode,true,true,&container))
{
/* the class reference could not be resolved */
return false; /* exception */
/* check access rights */
if (!is_accessible_member(referer,declarer,mi->flags)) {
- *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,
- "method is not accessible XXX add message");
+ int msglen;
+ char *message;
+
+ msglen = utf_strlen(declarer->name) + utf_strlen(mi->name) +
+ utf_strlen(mi->descriptor) + utf_strlen(referer->name) + 100;
+ message = MNEW(char,msglen);
+ strcpy(message,"method is not accessible (");
+ utf_sprint_classname(message+strlen(message),declarer);
+ strcat(message,".");
+ utf_sprint(message+strlen(message),mi->name);
+ utf_sprint(message+strlen(message),mi->descriptor);
+ strcat(message," from ");
+ utf_sprint_classname(message+strlen(message),referer->name);
+ strcat(message,")");
+ *exceptionptr = new_exception_message(string_java_lang_IllegalAccessException,message);
+ MFREE(message,char,msglen);
return false; /* exception */
}
instruction *ins = (instruction*)TYPEINFO_NEWOBJECT_INSTRUCTION(instanceslot->typeinfo);
classref_or_classinfo initclass = (ins) ? CLASSREF_OR_CLASSINFO(ins[-1].val.a)
: CLASSREF_OR_CLASSINFO(refmethod->class);
- TYPEINFO_INIT_CLASSREF_OR_CLASSINFO(tinfo,initclass);
tip = &tinfo;
+ if (!typeinfo_init_class(tip,initclass))
+ return false;
}
else {
tip = &(instanceslot->typeinfo);
Changes:
- $Id: resolve.h 2738 2005-06-18 16:37:34Z edwin $
+ $Id: resolve.h 2788 2005-06-22 16:08:51Z edwin $
*/
resolveLazy...only resolve if it does not
require loading classes
resolveEager..load classes if necessary
+ checkaccess......if true, access rights to the class are checked
link.............if true, guarantee that the returned class, if any,
has been linked
resolve_class_from_name(classinfo* referer,methodinfo *refmethod,
utf *classname,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result);
resolveLazy...only resolve if it does not
require loading classes
resolveEager..load classes if necessary
+ checkaccess......if true, access rights to the class are checked
link.............if true, guarantee that the returned class, if any,
has been linked
resolve_classref(methodinfo *refmethod,
constant_classref *ref,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result);
resolveLazy...only resolve if it does not
require loading classes
resolveEager..load classes if necessary
+ checkaccess......if true, access rights to the class are checked
link.............if true, guarantee that the returned class, if any,
has been linked
resolve_classref_or_classinfo(methodinfo *refmethod,
classref_or_classinfo cls,
resolve_mode_t mode,
+ bool checkaccess,
bool link,
classinfo **result);
IN:
d................type descriptor
+ checkaccess......if true, access rights to the class are checked
link.............if true, guarantee that the returned class, if any,
has been linked
OUT:
*******************************************************************************/
-bool resolve_class_from_typedesc(typedesc *d,bool link,classinfo **result);
+bool resolve_class_from_typedesc(typedesc *d,bool checkaccess,bool link,classinfo **result);
/* resolve_class ***************************************************************
- Resolve an unresolved class reference
+ Resolve an unresolved class reference. The class is also linked.
IN:
ref..............struct containing the reference
resolveLazy...only resolve if it does not
require loading classes
resolveEager..load classes if necessary
-
+ checkaccess......if true, access rights to the class are checked
+
OUT:
*result..........set to the result of resolution, or to NULL if
the reference has not been resolved
bool
resolve_class(unresolved_class *ref,
resolve_mode_t mode,
+ bool checkaccess,
classinfo **result);
/* resolve_field ***************************************************************
projects / cacao.git / commitdiff