//===--- JavaConstantPool.h - Java constant pool definition ---------------===//
//
//                              JnJVM
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#ifndef JNJVM_JAVA_CONSTANT_POOL_H
#define JNJVM_JAVA_CONSTANT_POOL_H

#include "mvm/JIT.h"
#include "mvm/Object.h"

#include "types.h"

namespace jnjvm {

class Class;
class CommonClass;
class Jnjvm;
class JavaConstantPool;
class JavaField;
class JavaMethod;
class JavaString;
class Reader;
class Signdef;
class Typedef;
class UTF8;


/// JavaConstantPool - This class represents a Java constant pool, a place where
/// a Java class makes external references such as classes and methods and
/// stores constants such as integers or UTF8s.
class JavaConstantPool {
public:
  
  /// classDef - The owning class of this constant pool.
  ///
  Class*  classDef;
  
  /// ctpSize - The number of entries in the constant pool.
  ///
  uint32 ctpSize;

  /// ctpType - The types of the constant pool entries.
  ///
  uint8*  ctpType;

  /// ctpDef - The values of the constant pool entries: may be constants or
  /// references to other entries.
  ///
  sint32* ctpDef;
  
  /// ctpRes - Objects resolved dynamically, e.g. UTF8s, classes, methods,
  /// fields, strings.
  ///
  void**  ctpRes; 
  
  /// CtpReaderClass - Reads a class entry.
  static uint32 CtpReaderClass(JavaConstantPool* ctp, Reader& reader,
                               uint32 index);
  
  /// CtpReaderInteger - Reads an integer entry.
  static uint32 CtpReaderInteger(JavaConstantPool* ctp, Reader& reader,
                                 uint32 index);
  
  /// CtpReaderFloat - Reads a float entry.
  static uint32 CtpReaderFloat(JavaConstantPool* ctp, Reader& reader,
                               uint32 index);
  
  /// CtpReaderClass - Reads an UTF8 entry.
  static uint32 CtpReaderUTF8(JavaConstantPool* ctp, Reader& reader,
                              uint32 index);
  
  /// CtpReaderNameAndType - Reads a name/signature entry.
  static uint32 CtpReaderNameAndType(JavaConstantPool* ctp, Reader& reader,
                                     uint32 index);
  
  /// CtpReaderFieldref - Reads a field entry.
  static uint32 CtpReaderFieldref(JavaConstantPool* ctp, Reader& reader,
                                  uint32 index);
  
  /// CtpReaderString - Reads a string entry.
  static uint32 CtpReaderString(JavaConstantPool* ctp, Reader& reader,
                                uint32 index);
  
  /// CtpReaderMethodref - Reads a method entry.
  static uint32 CtpReaderMethodref(JavaConstantPool* ctp, Reader& reader,
                                   uint32 index);
  
  /// CtpReaderInterfaceMethodref - Reads a method of an interface entry.
  static uint32 CtpReaderInterfaceMethodref(JavaConstantPool* ctp,
                                            Reader& reader,
                                            uint32 index);
   
  /// CtpReaderLong - Reads a long entry.
  static uint32 CtpReaderLong(JavaConstantPool* ctp, Reader& reader,
                              uint32 index);
  
  /// CtpReaderClass - Reads a double entry.
  static uint32 CtpReaderDouble(JavaConstantPool* ctp, Reader& reader,
                                uint32 index);

  static const uint32 ConstantUTF8;
  static const uint32 ConstantInteger;
  static const uint32 ConstantFloat;
  static const uint32 ConstantLong;
  static const uint32 ConstantDouble;
  static const uint32 ConstantClass;
  static const uint32 ConstantString;
  static const uint32 ConstantFieldref;
  static const uint32 ConstantMethodref;
  static const uint32 ConstantInterfaceMethodref;
  static const uint32 ConstantNameAndType;

  typedef uint32 (*ctpReader)(JavaConstantPool*, Reader&, uint32);

  /// funcsReader - Array of CtpReader* functions.
  ///
  static ctpReader funcsReader[16];

  /// isAStaticCall - Is the name/type at the given entry a reference to a
  /// static method?
  bool isAStaticCall(uint32 index) {
    return (ctpType[index] & 0x80) != 0;    
  }
  
  /// markAsStaticCall - Set the name/type entry as a reference to a static
  /// method.
  void markAsStaticCall(uint32 index) {
    ctpType[index] |= 0x80;
  }

  /// typeAt - Get the constant pool type of the given entry.
  ///
  uint8 typeAt(uint32 index) {
    return ctpType[index] & 0x7F;    
  }
  
  /// UTF8At - Get the UTF8 at the given entry.
  ///
  const UTF8* UTF8At(uint32 entry);
  
  /// UTF8At - Get the UTF8 referenced from this string entry.
  ///
  const UTF8* UTF8AtForString(uint32 entry) {
    return UTF8At(ctpDef[entry]);
  }

  /// FloatAt - Get the float at the given entry.
  ///
  float FloatAt(uint32 entry);

  /// IntegerAt - Get the int at the given entry.
  ///
  sint32 IntegerAt(uint32 entry);

  /// LongAt - Get the long at the given entry.
  ///
  sint64 LongAt(uint32 entry);

  /// DoubleAt - Get the double at the given entry.
  ///
  double DoubleAt(uint32 entry);

  /// isClassLoaded - Is the class at the given entry already loaded?
  ///
  CommonClass* isClassLoaded(uint32 index);

  /// resolveClassName - Get the name of the class referenced and returns
  /// it.
  ///
  const UTF8* resolveClassName(uint32 index);
 
  /// resolveNameAndType - Resolve the name/type at the given index,
  /// and returns the type.
  Typedef* resolveNameAndType(uint32 index);

  /// resolveNameAndSign - Resolve the name/sign at the given index,
  /// and returns the signature.
  Signdef* resolveNameAndSign(uint32 index);

  /// infoOfInterfaceOrVirtualMethod - Get the signature of the method
  /// referenced at the given entry.
  Signdef* infoOfInterfaceOrVirtualMethod(uint32 index);

  /// infoOfStaticOrSpecialMethod - Get the JIT representation of a
  /// non-virtual method. Also returns its signature and the Jnjvm
  /// representation.
  ///
  void* infoOfStaticOrSpecialMethod(uint32 index,
                                    uint32 access,
                                    Signdef*& sign,
                                    JavaMethod*& meth);
  
  /// nameOfStaticOrSpecialMethod - Get the name and the signature
  /// of a non-virtual method.
  ///
  void nameOfStaticOrSpecialMethod(uint32 index, const UTF8*& cl, 
                                   const UTF8*& name, Signdef*& sign);
  
  /// getClassIndexFromMethod - Get the entry of the class that owns
  /// the referenced method.
  ///
  uint32 getClassIndexFromMethod(uint32 index);

  /// getMethodClassIfLoaded - Returns the class of the given method if
  /// loaded, null if not.
  CommonClass* getMethodClassIfLoaded(uint32 index);
 
  /// infoOfField - Get the Typedef representation of the field referenced
  /// at the given entry. This does not involve any class loading.
  ///
  Typedef* infoOfField(uint32 index);
  
  /// infoOfMethod - Get the signature of the method referenced at the given
  /// entry and try to find the method. This does not involve any class
  /// loading.
  ///
  void infoOfMethod(uint32 index, uint32 access, CommonClass*& cl,
                    JavaMethod*& meth); 
 
  /// lookupField - Lookup the field at the given entry.
  ///
  JavaField* lookupField(uint32 index, bool stat);
  
  /// resolveString - Get the string referenced at the given
  /// index from the UTF8.
  JavaString* resolveString(const UTF8* utf8, uint16 index);
  
  /// resolveMethod - Resolve the class and the signature of the method. May
  /// perform class loading. This function is called just in time, ie when
  /// the method call is actually made and not yet resolved.
  ///
  void resolveMethod(uint32 index, CommonClass*& cl,
                     const UTF8*& utf8, Signdef*& sign);
  
  /// resolveField - Resolve the class and signature of the field. May
  /// perform class loading. This function is called just in time, ie when
  /// the field is accessed and not yet resolved.
  ///
  void resolveField(uint32 index, CommonClass*& cl, const UTF8*& utf8,
                    Typedef*& sign);
  
  /// loadClass - Loads the class and returns it. This is called just in time, 
  /// ie when the class will be used and not yet resolved, and also for
  /// two special instructions when JIIting: exception comparisons, and
  /// MULTIANEWARRAY. This function is also called by the classpath for
  /// loading exception classes referenced by a method.
  ///
  CommonClass* loadClass(uint32 index);

  /// JavaConstantPool - Default constructor.
  ///
  JavaConstantPool() {
    ctpRes = 0;
    ctpType = 0;
    ctpDef = 0;
    JInfo = 0;
  }
  
  /// JavaConstantPool - Reads the bytecode of the class to get
  /// the initial types and constants definitions.
  ///
  JavaConstantPool(Class*, Reader& reader);

  /// ~JavaConstantPool - Delete the constant pool.
  ///
  ~JavaConstantPool() {
    delete ctpRes;
    delete ctpDef;
    delete ctpType;
  }
  
  mvm::JITInfo* JInfo;
  template<typename Ty> 
  Ty *getInfo() {
    if (!JInfo) {
      JInfo = new Ty(this);
    }   

    assert((void*)dynamic_cast<Ty*>(JInfo) == (void*)JInfo &&
           "Invalid concrete type or multiple inheritence for getInfo");
    return static_cast<Ty*>(JInfo);
  }

};

} // end namespace jnjvm

#endif