int main() {
int test;
char line[1024], doubleName = 0;
while (gets(line)) {
int i, j, i1 = -1, i2 = -1, i3 = -1;
memset(all, 0, sizeof(int) * 12);
for (j = 0; j < strlen(line) - 1; doubleName ? j += 2 : j++) {
doubleName = 0;
if (isalpha(line[j])) {
if (line[j + 1] == 'b' || line[j + 1] == '#') {
i = getDoubleIndex(line[j], line[j + 1]);
doubleName = 1;
} else {
i = getSimpleIndex(line[j]);
}
if (i1 == -1) {
i1 = i;
} else if (i2 == -1) {
i2 = i;
} else {
i3 = i;
all[i1] = all[i2] = all[i3] = 1;
int recognized = 0;
for (i = 0; i < 12; i++) {
if (all[i] && all[(i + 4) % 12] && all[(i + 7) % 12]) {
recognized = 1;
char name[2];
int r = getSimpleName(i, name);
if (r != -1) {
printf("%s is a %c Major chord.\n", line, name[0]);
} else {
r = getDoubleName(i, name);
printf("%s is a %c%c Major chord.\n", line, name[0], name[1]);
}
break;
} else if (all[i] && all[(i + 3) % 12] && all[(i + 7) % 12]) {
recognized = 1;
char name[2];
int r = getSimpleName(i, name);
if (r != -1) {
printf("%s is a %c Minor chord.\n", line, name[0]);
} else {
r = getDoubleName(i, name);
printf("%s is a %c%c Major chord.\n", line, name[0], name[1]);
}
break;
}
}
if (!recognized) {
printf("%s is unrecognized.\n", line);
}
}
}
}
}
return 0;
}
void JavaClass::merge(const JavaClass *globalInstance) {
LOG_DEBUG("Merging instance of '%s' with global class info", getSimpleName());
_clazz = globalInstance->_clazz_global.get();
_methods = &globalInstance->_methods_global;
_fields = &globalInstance->_fields_global;
_default_constructor = globalInstance->_default_constructor;
}
void JavaClass::cacheConstructor(JNIEnv *env) {
LOG_DEBUG("Caching constructor in class '%s'", getSimpleName());
if (!isInitialized()) {
JavaExceptionUtils::throwExceptionOfType(env, kTypeIllegalStateException,
"Attempt to call cacheMethod without having set class info");
return;
}
std::string signature;
JavaClassUtils::makeSignature(signature, kTypeVoid, NULL);
_default_constructor = env->GetMethodID(_clazz_global.get(), "<init>", signature.c_str());
JavaExceptionUtils::checkException(env);
}
bool JavaClass::registerNativeMethods(JNIEnv *env) {
LOG_DEBUG("Registering native methods on class '%s'", getSimpleName());
if (_jni_methods.empty()) {
return false;
}
if (!isInitialized()) {
JavaExceptionUtils::throwRuntimeException(env, "Could not find cached class for %s", getCanonicalName());
return false;
}
bool result = (env->RegisterNatives(_clazz_global.get(), &_jni_methods[0], (jint)_jni_methods.size()) < 0);
_jni_methods.clear();
return result;
}
void JavaClass::setJavaObject(JNIEnv *env, jobject javaThis) {
LOG_DEBUG("Setting fields from Java object of type '%s' to native instance", getSimpleName());
// Set up field mappings, if this has not already been done
if (_field_mappings.empty()) {
mapFields();
}
for (FieldMap::const_iterator iter = _fields->begin(); iter != _fields->end(); ++iter) {
std::string key = iter->first;
LOG_DEBUG("Copying field '%s'", key.c_str());
jfieldID field = iter->second;
const FieldMapping *mapping = getFieldMapping(key.c_str());
if (field != NULL && mapping != NULL) {
if (TYPE_EQUALS(mapping->type, kTypeInt)) {
int *address = static_cast<int*>(mapping->address);
*address = env->GetIntField(javaThis, field);
} else if (TYPE_EQUALS(mapping->type, kTypeShort)) {
short *address = static_cast<short*>(mapping->address);
*address = env->GetShortField(javaThis, field);
} else if (TYPE_EQUALS(mapping->type, kTypeBool)) {
bool *address = static_cast<bool*>(mapping->address);
// The somewhat odd "? true : false" fixes a performance warning on windows,
// since GetBooleanField actually returns jboolean, not bool.
*address = env->GetBooleanField(javaThis, field) ? true : false;
} else if (TYPE_EQUALS(mapping->type, kTypeFloat)) {
float *address = static_cast<float*>(mapping->address);
*address = env->GetFloatField(javaThis, field);
} else if (TYPE_EQUALS(mapping->type, kTypeDouble)) {
double *address = static_cast<double*>(mapping->address);
*address = env->GetDoubleField(javaThis, field);
} else if (TYPE_EQUALS(mapping->type, kTypeString)) {
jstring string = (jstring)env->GetObjectField(javaThis, field);
JavaString *address = static_cast<JavaString*>(mapping->address);
address->set(env, string);
} else if (TYPE_EQUALS(mapping->type, kTypeByte)) {
unsigned char *address = static_cast<unsigned char*>(mapping->address);
*address = env->GetByteField(javaThis, field);
} else if (TYPE_EQUALS(mapping->type, kTypeChar)) {
wchar_t *address = static_cast<wchar_t*>(mapping->address);
*address = env->GetCharField(javaThis, field);
} else {
LOG_ERROR("Unable to copy data to field '%s'", key.c_str());
}
}
}
}
void JavaClass::addNativeMethod(const char *method_name, void *function, const char *return_type, ...) {
LOG_DEBUG("Adding native method '%s' to class '%s'", method_name, getSimpleName());
JNINativeMethod nativeMethod;
nativeMethod.name = const_cast<char*>(method_name);
nativeMethod.fnPtr = function;
va_list arguments;
va_start(arguments, return_type);
std::string signature;
JavaClassUtils::makeSignatureWithList(signature, return_type, arguments);
nativeMethod.signature = const_cast<char*>(strdup(signature.c_str()));
LOG_DEBUG("Native signature is '%s'", nativeMethod.signature);
va_end(arguments);
_jni_methods.push_back(nativeMethod);
}
void JavaClass::cacheField(JNIEnv *env, const char *field_name, const char *field_type) {
LOG_DEBUG("Caching field '%s' (type %s) in class '%s'", field_name, field_type, getSimpleName());
if (!isInitialized()) {
JavaExceptionUtils::throwExceptionOfType(env, kTypeIllegalStateException,
"Attempt to call cacheField without having set class info");
return;
}
std::string fieldTypeSignature;
JavaClassUtils::makeNameForSignature(fieldTypeSignature, field_type);
jfieldID field = env->GetFieldID(_clazz_global.get(), field_name, fieldTypeSignature.c_str());
JavaExceptionUtils::checkException(env);
if (field != NULL) {
_fields_global[field_name] = field;
} else {
JavaExceptionUtils::throwExceptionOfType(env, kTypeJavaClass(NoSuchFieldError),
"Field '%s' (type '%s') not found on class %s",
field_name, field_type, getCanonicalName());
}
}
jobject JavaClass::toJavaObject(JNIEnv *env) {
LOG_DEBUG("Converting native instance of '%s' to Java instance", getSimpleName());
if (_default_constructor == NULL) {
JavaExceptionUtils::throwExceptionOfType(env, kTypeIllegalStateException,
"Cannot call toJavaObject without a constructor (did you forget to call cacheConstructor() in initialize()?");
return NULL;
} else if (!isInitialized()) {
JavaExceptionUtils::throwExceptionOfType(env, kTypeIllegalStateException,
"Cannot call toJavaObject without registering class info");
return NULL;
}
// Set up field mappings, if this has not already been done
if (_field_mappings.empty()) {
mapFields();
}
JniLocalRef<jobject> result;
result.set(env->NewObject(_clazz, _default_constructor));
return toJavaObject(env, result.leak());
}
void JavaClass::cacheMethod(JNIEnv *env, const char* method_name, const char* return_type, ...) {
LOG_DEBUG("Caching method '%s' in class '%s'", method_name, getSimpleName());
if (!isInitialized()) {
JavaExceptionUtils::throwExceptionOfType(env, kTypeIllegalStateException,
"Attempt to call cacheMethod without having set class info");
return;
}
va_list arguments;
va_start(arguments, return_type);
std::string signature;
JavaClassUtils::makeSignatureWithList(signature, return_type, arguments);
va_end(arguments);
jmethodID method = env->GetMethodID(_clazz_global.get(), method_name, signature.c_str());
JavaExceptionUtils::checkException(env);
if (method != NULL) {
_methods_global[method_name] = method;
} else {
JavaExceptionUtils::throwExceptionOfType(env, kTypeJavaClass(NoSuchMethodError),
"Method '%s' (signature: %s) not found on class '%s'",
method_name, signature.c_str(), getCanonicalName());
}
}
