/*

 * Copyright 1997-2009 Sun Microsystems, Inc.  All Rights Reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_javaClasses.cpp.incl"

static bool find_field(instanceKlass* ik,

                       symbolOop name_symbol, symbolOop signature_symbol,

                       fieldDescriptor* fd,

                       bool allow_super = false) {

  if (allow_super)

    return ik->find_field(name_symbol, signature_symbol, fd) != NULL;

  else

    return ik->find_local_field(name_symbol, signature_symbol, fd);

}

// Helpful routine for computing field offsets at run time rather than hardcoding them

static void

compute_offset(int &dest_offset,

               klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol,

               bool allow_super = false) {

  fieldDescriptor fd;

  instanceKlass* ik = instanceKlass::cast(klass_oop);

  if (!find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {

    ResourceMark rm;

    tty->print_cr("Invalid layout of %s at %s", ik->external_name(), name_symbol->as_C_string());

    fatal("Invalid layout of preloaded class");

  }

  dest_offset = fd.offset();

}

// Same as above but for "optional" offsets that might not be present in certain JDK versions

static void

compute_optional_offset(int& dest_offset,

                        klassOop klass_oop, symbolOop name_symbol, symbolOop signature_symbol,

                        bool allow_super = false) {

  fieldDescriptor fd;

  instanceKlass* ik = instanceKlass::cast(klass_oop);

  if (find_field(ik, name_symbol, signature_symbol, &fd, allow_super)) {

    dest_offset = fd.offset();

  }

}

Handle java_lang_String::basic_create(int length, bool tenured, TRAPS) {

  // Create the String object first, so there's a chance that the String

  // and the char array it points to end up in the same cache line.

  oop obj;

  if (tenured) {

    obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_permanent_instance(CHECK_NH);

  } else {

    obj = instanceKlass::cast(SystemDictionary::string_klass())->allocate_instance(CHECK_NH);

  }

  // Create the char array.  The String object must be handlized here

  // because GC can happen as a result of the allocation attempt.

  Handle h_obj(THREAD, obj);

  typeArrayOop buffer;

  if (tenured) {

    buffer = oopFactory::new_permanent_charArray(length, CHECK_NH);

  } else {

    buffer = oopFactory::new_charArray(length, CHECK_NH);

  }

  // Point the String at the char array

  obj = h_obj();

  set_value(obj, buffer);

  // No need to zero the offset, allocation zero'ed the entire String object

  assert(offset(obj) == 0, "initial String offset should be zero");

//set_offset(obj, 0);

  set_count(obj, length);

  return h_obj;

}

Handle java_lang_String::basic_create_from_unicode(jchar* unicode, int length, bool tenured, TRAPS) {

  Handle h_obj = basic_create(length, tenured, CHECK_NH);

  typeArrayOop buffer = value(h_obj());

  for (int index = 0; index < length; index++) {

    buffer->char_at_put(index, unicode[index]);

  }

  return h_obj;

}

Handle java_lang_String::create_from_unicode(jchar* unicode, int length, TRAPS) {

  return basic_create_from_unicode(unicode, length, false, CHECK_NH);

}

Handle java_lang_String::create_tenured_from_unicode(jchar* unicode, int length, TRAPS) {

  return basic_create_from_unicode(unicode, length, true, CHECK_NH);

}

oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {

  Handle h_obj = basic_create_from_unicode(unicode, length, false, CHECK_0);

  return h_obj();

}

Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {

  if (utf8_str == NULL) {

    return Handle();

  }

  int length = UTF8::unicode_length(utf8_str);

  Handle h_obj = basic_create(length, false, CHECK_NH);

  if (length > 0) {

    UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);

  }

  return h_obj;

}

oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {

  Handle h_obj = create_from_str(utf8_str, CHECK_0);

  return h_obj();

}

Handle java_lang_String::create_from_symbol(symbolHandle symbol, TRAPS) {

  int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());

  Handle h_obj = basic_create(length, false, CHECK_NH);

  if (length > 0) {

    UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);

  }

  return h_obj;

}

// Converts a C string to a Java String based on current encoding

Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {

  assert(str != NULL, "bad arguments");

  typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);

  static to_java_string_fn_t _to_java_string_fn = NULL;

  if (_to_java_string_fn == NULL) {

    void *lib_handle = os::native_java_library();

    _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, hpi::dll_lookup(lib_handle, "NewStringPlatform"));

    if (_to_java_string_fn == NULL) {

      fatal("NewStringPlatform missing");

    }

  }

  jstring js = NULL;

  { JavaThread* thread = (JavaThread*)THREAD;

    assert(thread->is_Java_thread(), "must be java thread");

    HandleMark hm(thread);

    ThreadToNativeFromVM ttn(thread);

    js = (_to_java_string_fn)(thread->jni_environment(), str);

  }

  return Handle(THREAD, JNIHandles::resolve(js));

}

// Converts a Java String to a native C string that can be used for

// native OS calls.

char* java_lang_String::as_platform_dependent_str(Handle java_string, TRAPS) {

  typedef char* (*to_platform_string_fn_t)(JNIEnv*, jstring, bool*);

  static to_platform_string_fn_t _to_platform_string_fn = NULL;

  if (_to_platform_string_fn == NULL) {

    void *lib_handle = os::native_java_library();

    _to_platform_string_fn = CAST_TO_FN_PTR(to_platform_string_fn_t, hpi::dll_lookup(lib_handle, "GetStringPlatformChars"));

    if (_to_platform_string_fn == NULL) {

      fatal("GetStringPlatformChars missing");

    }

  }

  char *native_platform_string;

  { JavaThread* thread = (JavaThread*)THREAD;

    assert(thread->is_Java_thread(), "must be java thread");

    JNIEnv *env = thread->jni_environment();

    jstring js = (jstring) JNIHandles::make_local(env, java_string());

    bool is_copy;

    HandleMark hm(thread);

    ThreadToNativeFromVM ttn(thread);

    native_platform_string = (_to_platform_string_fn)(env, js, &is_copy);

    assert(is_copy == JNI_TRUE, "is_copy value changed");

    JNIHandles::destroy_local(js);

  }

  return native_platform_string;

}

Handle java_lang_String::char_converter(Handle java_string, jchar from_char, jchar to_char, TRAPS) {

  oop          obj    = java_string();

  // Typical usage is to convert all '/' to '.' in string.

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  // First check if any from_char exist

  int index; // Declared outside, used later

  for (index = 0; index < length; index++) {

    if (value->char_at(index + offset) == from_char) {

      break;

    }

  }

  if (index == length) {

    // No from_char, so do not copy.

    return java_string;

  }

  // Create new UNICODE buffer. Must handlize value because GC

  // may happen during String and char array creation.

  typeArrayHandle h_value(THREAD, value);

  Handle string = basic_create(length, false, CHECK_NH);

  typeArrayOop from_buffer = h_value();

  typeArrayOop to_buffer   = java_lang_String::value(string());

  // Copy contents

  for (index = 0; index < length; index++) {

    jchar c = from_buffer->char_at(index + offset);

    if (c == from_char) {

      c = to_char;

    }

    to_buffer->char_at_put(index, c);

  }

  return string;

}

jchar* java_lang_String::as_unicode_string(oop java_string, int& length) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

               length = java_lang_String::length(java_string);

  jchar* result = NEW_RESOURCE_ARRAY(jchar, length);

  for (int index = 0; index < length; index++) {

    result[index] = value->char_at(index + offset);

  }

  return result;

}

symbolHandle java_lang_String::as_symbol(Handle java_string, TRAPS) {

  oop          obj    = java_string();

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  symbolOop sym = SymbolTable::lookup_unicode(base, length, THREAD);

  return symbolHandle(THREAD, sym);

}

symbolOop java_lang_String::as_symbol_or_null(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  return SymbolTable::probe_unicode(base, length);

}

int java_lang_String::utf8_length(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

  return UNICODE::utf8_length(position, length);

}

char* java_lang_String::as_utf8_string(oop java_string) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);

  return UNICODE::as_utf8(position, length);

}

char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  assert(start + len <= length, "just checking");

  jchar* position = value->char_at_addr(offset + start);

  return UNICODE::as_utf8(position, len);

}

bool java_lang_String::equals(oop java_string, jchar* chars, int len) {

  assert(SharedSkipVerify ||

         java_string->klass() == SystemDictionary::string_klass(),

         "must be java_string");

  typeArrayOop value  = java_lang_String::value(java_string);

  int          offset = java_lang_String::offset(java_string);

  int          length = java_lang_String::length(java_string);

  if (length != len) {

    return false;

  }

  for (int i = 0; i < len; i++) {

    if (value->char_at(i + offset) != chars[i]) {

      return false;

    }

  }

  return true;

}

void java_lang_String::print(Handle java_string, outputStream* st) {

  oop          obj    = java_string();

  assert(obj->klass() == SystemDictionary::string_klass(), "must be java_string");

  typeArrayOop value  = java_lang_String::value(obj);

  int          offset = java_lang_String::offset(obj);

  int          length = java_lang_String::length(obj);

  int end = MIN2(length, 100);

  if (value == NULL) {

    // This can happen if, e.g., printing a String

    // object before its initializer has been called

    st->print_cr("NULL");

  } else {

    st->print("\"");

    for (int index = 0; index < length; index++) {

      st->print("%c", value->char_at(index + offset));

    }

    st->print("\"");

  }

}

oop java_lang_Class::create_mirror(KlassHandle k, TRAPS) {

  assert(k->java_mirror() == NULL, "should only assign mirror once");

  // Use this moment of initialization to cache modifier_flags also,

  // to support Class.getModifiers().  Instance classes recalculate

  // the cached flags after the class file is parsed, but before the

  // class is put into the system dictionary.

  int computed_modifiers = k->compute_modifier_flags(CHECK_0);

  k->set_modifier_flags(computed_modifiers);

  if (SystemDictionary::class_klass_loaded()) {

    // Allocate mirror (java.lang.Class instance)

    Handle mirror = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

    // Setup indirections

    mirror->obj_field_put(klass_offset,  k());

    k->set_java_mirror(mirror());

    // It might also have a component mirror.  This mirror must already exist.

    if (k->oop_is_javaArray()) {

      Handle comp_mirror;

      if (k->oop_is_typeArray()) {

        BasicType type = typeArrayKlass::cast(k->as_klassOop())->element_type();

        comp_mirror = Universe::java_mirror(type);

        assert(comp_mirror.not_null(), "must have primitive mirror");

      } else if (k->oop_is_objArray()) {

        klassOop element_klass = objArrayKlass::cast(k->as_klassOop())->element_klass();

        if (element_klass != NULL

            && (Klass::cast(element_klass)->oop_is_instance() ||

                Klass::cast(element_klass)->oop_is_javaArray())) {

          comp_mirror = Klass::cast(element_klass)->java_mirror();

          assert(comp_mirror.not_null(), "must have element mirror");

        }

        // else some object array internal to the VM, like systemObjArrayKlassObj

      }

      if (comp_mirror.not_null()) {

        // Two-way link between the array klass and its component mirror:

        arrayKlass::cast(k->as_klassOop())->set_component_mirror(comp_mirror());

        set_array_klass(comp_mirror(), k->as_klassOop());

      }

    }

    return mirror();

  } else {

    return NULL;

  }

}

oop java_lang_Class::create_basic_type_mirror(const char* basic_type_name, BasicType type, TRAPS) {

  // This should be improved by adding a field at the Java level or by

  // introducing a new VM klass (see comment in ClassFileParser)

  oop java_class = instanceKlass::cast(SystemDictionary::class_klass())->allocate_permanent_instance(CHECK_0);

  if (type != T_VOID) {

    klassOop aklass = Universe::typeArrayKlassObj(type);

    assert(aklass != NULL, "correct bootstrap");

    set_array_klass(java_class, aklass);

  }

  return java_class;

}

klassOop java_lang_Class::as_klassOop(oop java_class) {

  //%note memory_2

  klassOop k = klassOop(java_class->obj_field(klass_offset));

  assert(k == NULL || k->is_klass(), "type check");

  return k;

}

void java_lang_Class::print_signature(oop java_class, outputStream* st) {

  assert(java_lang_Class::is_instance(java_class), "must be a Class object");

  symbolOop name = NULL;

  bool is_instance = false;

  if (is_primitive(java_class)) {

    name = vmSymbols::type_signature(primitive_type(java_class));

  } else {

    klassOop k = as_klassOop(java_class);

    is_instance = Klass::cast(k)->oop_is_instance();

    name = Klass::cast(k)->name();

  }

  if (name == NULL) {

    st->print("<null>");

    return;

  }

  if (is_instance)  st->print("L");

  st->write((char*) name->base(), (int) name->utf8_length());

  if (is_instance)  st->print(";");

}

symbolOop java_lang_Class::as_signature(oop java_class, bool intern_if_not_found, TRAPS) {

  assert(java_lang_Class::is_instance(java_class), "must be a Class object");

  symbolOop name = NULL;

  if (is_primitive(java_class)) {

    return vmSymbols::type_signature(primitive_type(java_class));

  } else {

    klassOop k = as_klassOop(java_class);

    if (!Klass::cast(k)->oop_is_instance()) {

      return Klass::cast(k)->name();

    } else {

      ResourceMark rm;

      const char* sigstr = Klass::cast(k)->signature_name();

      int         siglen = (int) strlen(sigstr);

      if (!intern_if_not_found)

        return SymbolTable::probe(sigstr, siglen);

      else

        return oopFactory::new_symbol(sigstr, siglen, THREAD);

    }

  }

}

klassOop java_lang_Class::array_klass(oop java_class) {

  klassOop k = klassOop(java_class->obj_field(array_klass_offset));

  assert(k == NULL || k->is_klass() && Klass::cast(k)->oop_is_javaArray(), "should be array klass");

  return k;

}

void java_lang_Class::set_array_klass(oop java_class, klassOop klass) {

  assert(klass->is_klass() && Klass::cast(klass)->oop_is_javaArray(), "should be array klass");

  java_class->obj_field_put(array_klass_offset, klass);

}

methodOop java_lang_Class::resolved_constructor(oop java_class) {

  oop constructor = java_class->obj_field(resolved_constructor_offset);

  assert(constructor == NULL || constructor->is_method(), "should be method");

  return methodOop(constructor);

}

void java_lang_Class::set_resolved_constructor(oop java_class, methodOop constructor) {

  assert(constructor->is_method(), "should be method");

  java_class->obj_field_put(resolved_constructor_offset, constructor);

}

bool java_lang_Class::is_primitive(oop java_class) {

  // should assert:

  //assert(java_lang_Class::is_instance(java_class), "must be a Class object");

  klassOop k = klassOop(java_class->obj_field(klass_offset));

  return k == NULL;

}

BasicType java_lang_Class::primitive_type(oop java_class) {

  assert(java_lang_Class::is_primitive(java_class), "just checking");

  klassOop ak = klassOop(java_class->obj_field(array_klass_offset));

  BasicType type = T_VOID;

  if (ak != NULL) {

    // Note: create_basic_type_mirror above initializes ak to a non-null value.

    type = arrayKlass::cast(ak)->element_type();

  } else {

    assert(java_class == Universe::void_mirror(), "only valid non-array primitive");

  }

  assert(Universe::java_mirror(type) == java_class, "must be consistent");

  return type;

}

BasicType java_lang_Class::as_BasicType(oop java_class, klassOop* reference_klass) {

  assert(java_lang_Class::is_instance(java_class), "must be a Class object");

  if (is_primitive(java_class)) {

    if (reference_klass != NULL)

      (*reference_klass) = NULL;

    return primitive_type(java_class);

  } else {

    if (reference_klass != NULL)

      (*reference_klass) = as_klassOop(java_class);

    return T_OBJECT;

  }

}

oop java_lang_Class::primitive_mirror(BasicType t) {

  oop mirror = Universe::java_mirror(t);

  assert(mirror != NULL && mirror->is_a(SystemDictionary::class_klass()), "must be a Class");

  assert(java_lang_Class::is_primitive(mirror), "must be primitive");

  return mirror;

}

bool java_lang_Class::offsets_computed = false;

int  java_lang_Class::classRedefinedCount_offset = -1;

int  java_lang_Class::parallelCapable_offset = -1;

void java_lang_Class::compute_offsets() {

  assert(!offsets_computed, "offsets should be initialized only once");

  offsets_computed = true;