#include "utilities/endian.hpp"

#include "utilities/growableArray.hpp"

// goal is to supply file access which is faster and smaller than the jar format.

// It should be noted that unlike jars, information stored in an image is in native

// endian format. This allows the image to be mapped into memory without endian

// translation.  This also means that images are platform dependent.

//         |   Index   |

//         |          Flags          |

//         +-------------------------+

//         |      Resource Count     |

//         +-------------------------+

//         |       Table Length      |

// Flags - various image wide flags (future).

// Resource count - number of resources in the file.

// Table length - the length of lookup tables used in the index.

//                index and meta data.

// The index contains information related to resource lookup. The algorithm

// in the form /<module>/<package>/<base>.<extension>  return the resource location

//     redirectIndex = hash(path, DEFAULT_SEED) % table_length;

//     locationIndex = redirect < 0 ? -1 - redirect : hash(path, redirect) % table_length;

// The following is the format of the index;

//                     full survey of resources in the image.  Offset of zero

//                     indicates no attributes.

// Strings - Collection of zero terminated UTF-8 strings used by the index and

// Note that the memory mapped index assumes 32 bit alignment of each component

// in the index.

//

// Endianness of an image.

// An image booted by hotspot is always in native endian.  However, it is possible

// to read (by the JDK) in alternate endian format.  Primarily, this is during

// cross platform scenarios.  Ex, where javac needs to read an embedded image

// to access classes for crossing compilation.

class ImageFileReader; // forward declaration

class ImageStrings VALUE_OBJ_CLASS_SPEC {

  u1* _data; // Data bytes for strings.

  u4 _size; // Number of bytes in the string table.

  enum {

    // Not found result from find routine.

    NOT_FOUND = -1,

    // Prime used to generate hash for Perfect Hashing.

    HASH_MULTIPLIER = 0x01000193

  };

    guarantee(offset < _size, "offset exceeds string table size");

  // Compute the Perfect Hashing hash code for the supplied UTF-8 string.

  static s4 hash_code(const char* string, s4 seed);

  // Match up a string in a perfect hash table.  Result still needs validation

  // for precise match.

  static s4 find(Endian* endian, const char* name, s4* redirect, u4 length);

  // Test to see if UTF-8 string begins with the start UTF-8 string.  If so,

  // return non-NULL address of remaining portion of string.  Otherwise, return

  // NULL.  Used to test sections of a path without copying from image string

  // table.

  // Test to see if UTF-8 string begins with start char.  If so, return non-NULL

  // address of remaining portion of string.  Otherwise, return NULL.  Used

  // to test a character of a path without copying.

  inline static const char* starts_with(const char* string, const char ch) {

    return *string == ch ? string + 1 : NULL;

  }

// Manage image file location attribute data.  Within an image, a location's

//    after the index.

class ImageLocation VALUE_OBJ_CLASS_SPEC {

  enum {

    ATTRIBUTE_END,          // End of attribute stream marker

    ATTRIBUTE_MODULE,       // String table offset of module name

    ATTRIBUTE_PARENT,       // String table offset of resource path parent

    ATTRIBUTE_BASE,         // String table offset of resource path base

    ATTRIBUTE_EXTENSION,    // String table offset of resource path extension

    ATTRIBUTE_OFFSET,       // Container byte offset of resource

    ATTRIBUTE_COMPRESSED,   // In image byte size of the compressed resource

    ATTRIBUTE_UNCOMPRESSED, // In memory byte size of the uncompressed resource

    ATTRIBUTE_COUNT         // Number of attribute kinds

  };

    guarantee(kind < ATTRIBUTE_COUNT, "invalid attribute kind");

    guarantee(0 < n && n <= 8, "invalid attribute value length");

  ImageLocation() {

    clear_data();

  }

  ImageLocation(u1* data) {

    clear_data();

    set_data(data);

  }

  // Inflates the attribute stream into individual values stored in the long

  // array _attributes. This allows an attribute value to be quickly accessed by

  // direct indexing. Unspecified values default to zero.

  void set_data(u1* data);

  // Zero all attribute values.

  void clear_data();

    guarantee(ATTRIBUTE_END < kind && kind < ATTRIBUTE_COUNT, "invalid attribute kind");

//

// NOTE: needs revision.

// Each loader requires set of module meta data to identify which modules and

// packages are managed by that loader.  Currently, there is one image file per

// builtin loader, so only one  module meta data resource per file.

//

// Each element in the module meta data is a native endian 4 byte integer.  Note

// that entries with zero offsets for string table entries should be ignored (

// padding for hash table lookup.)

//

// Format:

//    Count of package to module entries

//    Count of module to package entries

//    Perfect Hash redirect table[Count of package to module entries]

//    Package to module entries[Count of package to module entries]

//        Offset to package name in string table

//        Offset to module name in string table

//    Perfect Hash redirect table[Count of module to package entries]

//    Module to package entries[Count of module to package entries]

//        Offset to module name in string table

//        Count of packages in module

//        Offset to first package in packages table

//    Packages[]

//        Offset to package name in string table

//

// Manage the image module meta data.

class ImageModuleData : public CHeapObj<mtClass> {

  class Header VALUE_OBJ_CLASS_SPEC {

  private:

    u4 _ptm_count;      // Count of package to module entries

    u4 _mtp_count;      // Count of module to package entries

  public:

    inline u4 ptm_count(Endian* endian) const { return endian->get(_ptm_count); }

    inline u4 mtp_count(Endian* endian) const { return endian->get(_mtp_count); }

  };

  // Hashtable entry

  class HashData VALUE_OBJ_CLASS_SPEC {

  private:

    u4 _name_offset;    // Name offset in string table

  public:

    inline s4 name_offset(Endian* endian) const { return endian->get(_name_offset); }

  };

  // Package to module hashtable entry

  class PTMData : public HashData {

  private:

    u4 _module_name_offset; // Module name offset in string table

  public:

    inline s4 module_name_offset(Endian* endian) const { return endian->get(_module_name_offset); }

  };

  // Module to package hashtable entry

  class MTPData : public HashData {

  private:

    u4 _package_count;     // Number of packages in module

    u4 _package_offset;    // Offset in package list

  public:

    inline u4 package_count(Endian* endian)  const { return endian->get(_package_count); }

    inline u4 package_offset(Endian* endian) const { return endian->get(_package_offset); }

  const ImageFileReader* _image_file; // Source image file

  Endian* _endian;                    // Endian handler

  ImageStrings _strings;              // Image file strings

  u1* _data;                          // Module data resource data

  u8 _data_size;                      // Size of resource data

  Header* _header;                    // Module data header

  s4* _ptm_redirect;                  // Package to module hashtable redirect

  PTMData* _ptm_data;                 // Package to module data

  s4* _mtp_redirect;                  // Module to packages hashtable redirect

  MTPData* _mtp_data;                 // Module to packages data

  s4* _mtp_packages;                  // Package data (name offsets)

  // Return a string from the string table.

  inline const char* get_string(u4 offset) {

    return _strings.get(offset);

  }

  inline u4 mtp_package(u4 index) {

    return _endian->get(_mtp_packages[index]);

  }

public:

  ImageModuleData(const ImageFileReader* image_file, const char* module_data_name);

  ~ImageModuleData();

  // Return the name of the module data resource.

  static void module_data_name(char* buffer, const char* image_file_name);

  // Return the module in which a package resides.  Returns NULL if not found.

  const char* package_to_module(const char* package_name);

  // Returns all the package names in a module.  Returns NULL if module not found.

  GrowableArray<const char*>* module_to_packages(const char* module_name);

};

// Image file header, starting at offset 0.

class ImageHeader VALUE_OBJ_CLASS_SPEC {

private:

  u4 _magic;           // Image file marker

  u4 _version;         // Image file major version number

  u4 _flags;           // Image file flags

  u4 _resource_count;  // Number of resources in file

  u4 _table_length;    // Number of slots in index tables

  u4 _locations_size;  // Number of bytes in attribute table

  u4 _strings_size;    // Number of bytes in string table

public:

  u4 magic() const { return _magic; }

  u4 magic(Endian* endian) const { return endian->get(_magic); }

  void set_magic(Endian* endian, u4 magic) { return endian->set(_magic, magic); }

  u4 major_version(Endian* endian) const { return endian->get(_version) >> 16; }

  u4 minor_version(Endian* endian) const { return endian->get(_version) & 0xFFFF; }

  void set_version(Endian* endian, u4 major_version, u4 minor_version) {

    return endian->set(_version, major_version << 16 | minor_version);

  }

  u4 flags(Endian* endian) const { return endian->get(_flags); }

  void set_flags(Endian* endian, u4 value) { return endian->set(_flags, value); }

  u4 resource_count(Endian* endian) const { return endian->get(_resource_count); }

  void set_resource_count(Endian* endian, u4 count) { return endian->set(_resource_count, count); }

  u4 table_length(Endian* endian) const { return endian->get(_table_length); }

  void set_table_length(Endian* endian, u4 count) { return endian->set(_table_length, count); }

  u4 locations_size(Endian* endian) const { return endian->get(_locations_size); }

  void set_locations_size(Endian* endian, u4 size) { return endian->set(_locations_size, size); }

  u4 strings_size(Endian* endian) const { return endian->get(_strings_size); }

  void set_strings_size(Endian* endian, u4 size) { return endian->set(_strings_size, size); }

};

// Max path length limit independent of platform.  Windows max path is 1024,

// other platforms use 4096.  The JCK fails several tests when 1024 is used.

#define IMAGE_MAX_PATH 4096

// Manage the image file.

// ImageFileReader manages the content of an image file.

// Initially, the header of the image file is read for validation.  If valid,

// values in the header are used calculate the size of the image index.  The

// index is then memory mapped to allow load on demand and sharing.  The

// -XX:+MemoryMapImage flag determines if the entire file is loaded (server use.)

// An image can be used by Hotspot and multiple reference points in the JDK, thus

// it is desirable to share a reader.  To accomodate sharing, a share table is

// defined (see ImageFileReaderTable in imageFile.cpp)  To track the number of

// uses, ImageFileReader keeps a use count (_use).  Use is incremented when

// 'opened' by reference point and decremented when 'closed'.  Use of zero

// leads the ImageFileReader to be actually closed and discarded.

class ImageFileReader : public CHeapObj<mtClass> {

private:

  // Manage a number of image files such that an image can be shared across

  // multiple uses (ex. loader.)

  static GrowableArray<ImageFileReader*>* _reader_table;

  char* _name;         // Name of image

  s4 _use;             // Use count

  int _fd;             // File descriptor

  Endian* _endian;     // Endian handler

  u8 _file_size;       // File size in bytes

  ImageHeader _header; // Image header

  size_t _index_size;  // Total size of index

  u1* _index_data;     // Raw index data

  s4* _redirect_table; // Perfect hash redirect table

  u4* _offsets_table;  // Location offset table

  u1* _location_bytes; // Location attributes

  u1* _string_bytes;   // String table

  ImageFileReader(const char* name, bool big_endian);

  ~ImageFileReader();

      table_length() * sizeof(u4) * 2 + locations_size() + strings_size();

  enum {

    // Image file marker.

    IMAGE_MAGIC = 0xCAFEDADA,

    // Endian inverted Image file marker.

    IMAGE_MAGIC_INVERT = 0xDADAFECA,

    // Image file major version number.

    MAJOR_VERSION = 1,

    // Image file minor version number.

    MINOR_VERSION = 0

  };

  // Open an image file, reuse structure if file already open.

  static ImageFileReader* open(const char* name, bool big_endian = Endian::is_big_endian());

  // Close an image file if the file is not in use elsewhere.

  static void close(ImageFileReader *reader);

  // Return an id for the specifed ImageFileReader.

  static u8 readerToID(ImageFileReader *reader);

  // Validate the image id.

  static bool idCheck(u8 id);

  // Return an id for the specifed ImageFileReader.

  static ImageFileReader* idToReader(u8 id);