/*
 * Copyright (C) 2008 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
/*
 * Basic reflection calls and utility functions.
 */
#ifndef _DALVIK_REFLECT_REFLECT
#define _DALVIK_REFLECT_REFLECT

bool dvmReflectStartup(void);
bool dvmReflectProxyStartup(void);
bool dvmReflectAnnotationStartup(void);
void dvmReflectShutdown(void);

/*
 * During startup, validate the "box" classes, e.g. java/lang/Integer.
 */
bool dvmValidateBoxClasses();

/*
 * Get all fields declared by a class.
 *
 * Includes both class and instance fields.
 */
ArrayObject* dvmGetDeclaredFields(ClassObject* clazz, bool publicOnly);

/*
 * Get all constructors declared by a class.
 */
ArrayObject* dvmGetDeclaredConstructors(ClassObject* clazz, bool publicOnly);

/*
 * Get all methods declared by a class.
 *
 * This includes both static and virtual methods, and can include private
 * members if "publicOnly" is false.  It does not include Miranda methods,
 * since those weren't declared in the class, or constructors.
 */
ArrayObject* dvmGetDeclaredMethods(ClassObject* clazz, bool publicOnly);

/*
 * Get all interfaces a class implements. If this is unable to allocate
 * the result array, this raises an OutOfMemoryError and returns NULL.
 */
ArrayObject* dvmGetInterfaces(ClassObject* clazz);

/*
 * Convert slot numbers back to objects.
 */
Field* dvmSlotToField(ClassObject* clazz, int slot);
Method* dvmSlotToMethod(ClassObject* clazz, int slot);

/*
 * Convert a primitive value, performing a widening conversion if necessary.
 */
int dvmConvertPrimitiveValue(PrimitiveType srcType,
    PrimitiveType dstType, const s4* srcPtr, s4* dstPtr);

/*
 * Convert the argument to the specified type.
 *
 * Returns the width of the argument (1 for most types, 2 for J/D, -1 on
 * error).
 */
int dvmConvertArgument(DataObject* arg, ClassObject* type, s4* ins);

/*
 * Create a wrapper object for a primitive data type.  If "returnType" is
 * not primitive, this just returns "value" cast to an object.
 */
DataObject* dvmWrapPrimitive(JValue value, ClassObject* returnType);

/*
 * Unwrap a boxed primitive.  If "returnType" is not primitive, this just
 * returns "value" cast into a JValue.
 */
bool dvmUnwrapPrimitive(Object* value, ClassObject* returnType,
    JValue* pResult);

/*
 * Return the class object that matches the method's signature.  For
 * primitive types, returns the box class.
 */
ClassObject* dvmGetBoxedReturnType(const Method* meth);

/*
 * JNI reflection support.
 */
Field* dvmGetFieldFromReflectObj(Object* obj);
Method* dvmGetMethodFromReflectObj(Object* obj);
Object* dvmCreateReflectObjForField(const ClassObject* clazz, Field* field);
Object* dvmCreateReflectObjForMethod(const ClassObject* clazz, Method* method);

/*
 * Quick test to determine if the method in question is a reflection call.
 * Used for some stack parsing.  Currently defined as "the method's declaring
 * class is java.lang.reflect.Method".
 */
INLINE bool dvmIsReflectionMethod(const Method* method)
{
    return (method->clazz == gDvm.classJavaLangReflectMethod);
}

/*
 * Proxy class generation.
 */
ClassObject* dvmGenerateProxyClass(StringObject* str, ArrayObject* interfaces,
    Object* loader);

/*
 * Create a new java.lang.reflect.Method object based on "meth".
 */
Object* dvmCreateReflectMethodObject(const Method* meth);

/*
 * Return an array of Annotation objects for the specified piece.  For method
 * parameters this is an array of arrays of Annotation objects.
 *
 * Method also applies to Constructor.
 */
ArrayObject* dvmGetClassAnnotations(const ClassObject* clazz);
ArrayObject* dvmGetMethodAnnotations(const Method* method);
ArrayObject* dvmGetFieldAnnotations(const Field* field);
ArrayObject* dvmGetParameterAnnotations(const Method* method);

/*
 * Find the default value for an annotation member.
 */
Object* dvmGetAnnotationDefaultValue(const Method* method);

/*
 * Get the list of thrown exceptions for a method.  Returns NULL if there
 * are no exceptions listed.
 */
ArrayObject* dvmGetMethodThrows(const Method* method);

/*
 * Get the Signature annotation.
 */
ArrayObject* dvmGetClassSignatureAnnotation(const ClassObject* clazz);
ArrayObject* dvmGetMethodSignatureAnnotation(const Method* method);
ArrayObject* dvmGetFieldSignatureAnnotation(const Field* field);

/*
 * Get the EnclosingMethod attribute from an annotation.  Returns a Method
 * object, or NULL.
 */
Object* dvmGetEnclosingMethod(const ClassObject* clazz);

/*
 * Return clazz's declaring class, or NULL if there isn't one.
 */
ClassObject* dvmGetDeclaringClass(const ClassObject* clazz);

/*
 * Return clazz's enclosing class, or NULL if there isn't one.
 */
ClassObject* dvmGetEnclosingClass(const ClassObject* clazz);

/*
 * Get the EnclosingClass attribute from an annotation.  If found, returns
 * "true".  A String with the original name of the class and the original
 * access flags are returned through the arguments.  (The name will be NULL
 * for an anonymous inner class.)
 */
bool dvmGetInnerClass(const ClassObject* clazz, StringObject** pName,
    int* pAccessFlags);

/*
 * Get an array of class objects from the MemberClasses annotation.  Returns
 * NULL if none found.
 */
ArrayObject* dvmGetDeclaredClasses(const ClassObject* clazz);

/*
 * Used to pass values out of annotation (and encoded array) processing
 * functions.
 */
typedef struct AnnotationValue {
    JValue  value;
    u1      type;
} AnnotationValue;


/**
 * Iterator structure for iterating over DexEncodedArray instances. The
 * structure should be treated as opaque.
 */
typedef struct {
    const u1* cursor;                    /* current cursor */
    u4 elementsLeft;                     /* number of elements left to read */
    const DexEncodedArray* encodedArray; /* instance being iterated over */
    u4 size;                             /* number of elements in instance */
    const ClassObject* clazz;            /* class to resolve with respect to */
} EncodedArrayIterator;

/**
 * Initializes an encoded array iterator.
 * 
 * @param iterator iterator to initialize
 * @param encodedArray encoded array to iterate over
 * @param clazz class to use when resolving strings and types
 */
void dvmEncodedArrayIteratorInitialize(EncodedArrayIterator* iterator,
        const DexEncodedArray* encodedArray, const ClassObject* clazz);

/**
 * Returns whether there are more elements to be read.
 */
bool dvmEncodedArrayIteratorHasNext(const EncodedArrayIterator* iterator);

/**
 * Returns the next decoded value from the iterator, advancing its
 * cursor. This returns primitive values in their corresponding union
 * slots, and returns everything else (including nulls) as object
 * references in the "l" union slot.
 * 
 * The caller must call dvmReleaseTrackedAlloc() on any returned reference.
 * 
 * @param value pointer to store decoded value into
 * @returns true if a value was decoded and the cursor advanced; false if
 * the last value had already been decoded or if there was a problem decoding
 */
bool dvmEncodedArrayIteratorGetNext(EncodedArrayIterator* iterator,
        AnnotationValue* value);

#endif /*_DALVIK_REFLECT_REFLECT*/