SLang_Class_Type *_pSLclass_get_class (SLtype type)
{
SLang_Class_Type *cl;
if (NULL == (cl = lookup_class (type)))
SLang_exit_error ("Application error: Type %d not registered", (int) type);
return cl;
}
/*
* boolean nativeInit()
*
* Lookup and cache classes and methods.
*/
JNIEXPORT jboolean JNICALL Java_eu_gounot_bnfdata_provider_SuggestionsProvider_nativeInit
(JNIEnv *env, jobject j_this)
{
j_string_class = lookup_class(env, "java/lang/String");
if (j_string_class == NULL)
return JNI_FALSE;
j_mc_class = lookup_class(env, "android/database/MatrixCursor");
if (j_mc_class == NULL)
return JNI_FALSE;
j_mc_constructor = (*env)->GetMethodID(env, j_mc_class, "<init>", "([Ljava/lang/String;)V");
if (j_mc_constructor == NULL)
return JNI_FALSE;
j_mc_add_row = (*env)->GetMethodID(env, j_mc_class, "addRow", "([Ljava/lang/Object;)V");
if (j_mc_add_row == NULL)
return JNI_FALSE;
return JNI_TRUE;
}
static bool
qualify_syscall_class(const char *s, struct number_set *set)
{
const unsigned int n = lookup_class(s);
if (!n)
return false;
for (unsigned int p = 0; p < SUPPORTED_PERSONALITIES; ++p) {
for (unsigned int i = 0; i < nsyscall_vec[p]; ++i) {
if (sysent_vec[p][i].sys_name &&
(sysent_vec[p][i].sys_flags & n) == n)
add_number_to_set_array(i, set, p);
}
}
return true;
}
struct type *
java_lookup_class (char *name)
{
struct symbol *sym;
sym = lookup_symbol (name, expression_context_block, STRUCT_DOMAIN, NULL);
if (sym != NULL)
return SYMBOL_TYPE (sym);
#if 0
CORE_ADDR addr;
if (called from parser)
{
call lookup_class (or similar) in inferior;
if not
found:
return NULL;
addr = found in inferior;
}
static tree
parse_signature_type (const unsigned char **ptr, const unsigned char *limit)
{
tree type;
if (*ptr >= limit)
abort ();
switch (**ptr)
{
case 'B': (*ptr)++; return byte_type_node;
case 'C': (*ptr)++; return char_type_node;
case 'D': (*ptr)++; return double_type_node;
case 'F': (*ptr)++; return float_type_node;
case 'S': (*ptr)++; return short_type_node;
case 'I': (*ptr)++; return int_type_node;
case 'J': (*ptr)++; return long_type_node;
case 'Z': (*ptr)++; return boolean_type_node;
case 'V': (*ptr)++; return void_type_node;
case '[':
for ((*ptr)++; (*ptr) < limit && ISDIGIT (**ptr); ) (*ptr)++;
type = parse_signature_type (ptr, limit);
type = build_java_array_type (type, -1);
break;
case 'L':
{
const unsigned char *start = ++(*ptr);
const unsigned char *str = start;
for ( ; ; str++)
{
if (str >= limit)
abort ();
if (*str == ';')
break;
}
*ptr = str+1;
type = lookup_class (unmangle_classname ((const char *) start, str - start));
break;
}
default:
abort ();
}
return promote_type (type);
}
void
qualify(const char *s)
{
const struct qual_options *opt;
char *copy;
const char *p;
int not;
unsigned int i;
if (num_quals == 0)
reallocate_qual(MIN_QUALS);
opt = &qual_options[0];
for (i = 0; (p = qual_options[i].option_name); i++) {
unsigned int len = strlen(p);
if (strncmp(s, p, len) == 0 && s[len] == '=') {
opt = &qual_options[i];
s += len + 1;
break;
}
}
not = 0;
if (*s == '!') {
not = 1;
s++;
}
if (strcmp(s, "none") == 0) {
not = 1 - not;
s = "all";
}
if (strcmp(s, "all") == 0) {
for (i = 0; i < num_quals; i++) {
qualify_one(i, opt->bitflag, not, -1);
}
return;
}
for (i = 0; i < num_quals; i++) {
qualify_one(i, opt->bitflag, !not, -1);
}
copy = strdup(s);
if (!copy)
die_out_of_memory();
for (p = strtok(copy, ","); p; p = strtok(NULL, ",")) {
int n;
if (opt->bitflag == QUAL_TRACE && (n = lookup_class(p)) > 0) {
unsigned pers;
for (pers = 0; pers < SUPPORTED_PERSONALITIES; pers++) {
for (i = 0; i < nsyscall_vec[pers]; i++)
if (sysent_vec[pers][i].sys_flags & n)
qualify_one(i, opt->bitflag, not, pers);
}
continue;
}
if (opt->qualify(p, opt->bitflag, not)) {
error_msg_and_die("invalid %s '%s'",
opt->argument_name, p);
}
}
free(copy);
return;
}
int SLclass_is_class_defined (SLtype type)
{
return (NULL != lookup_class (type));
}
